Skip to content

Instantly share code, notes, and snippets.

@cevek
Created January 25, 2017 16:08
Show Gist options
  • Save cevek/c22bcf2f97288f12b0a2dc3b2b99b69a to your computer and use it in GitHub Desktop.
Save cevek/c22bcf2f97288f12b0a2dc3b2b99b69a to your computer and use it in GitHub Desktop.

native string.js:

indexOf:

(s,t){
if((%IS_VAR(this)===null)||(this===(void 0)))🔶️throw 🔶️%make_type_error(17,"String.prototype.indexOf");
var u=(🔶️%_ToString(this));
s=(🔶️%_ToString(s));
var v=(🔶️%_ToInteger(t));
if(v<0)v=0;
if(v>u⚠️.length)v=u⚠️.length;
return 🔶️%StringIndexOf(u,s,v);
}

lastIndexOf:

(w,x){
if((%IS_VAR(this)===null)||(this===(void 0)))🔶️throw 🔶️%make_type_error(17,"String.prototype.lastIndexOf");
var y=(🔶️%_ToString(this));
var z=y.length;
var w=(🔶️%_ToString(w));
var A=w.length;
var v=z-A;
var t=(🔶️%_ToNumber(x));
if(!(!%_IsSmi(%IS_VAR(t))&&!(t==t))){
t=(🔶️%_ToInteger(t));
if(t<0){
t=0;
}
if(t+A<z){
v=t;
}
}
if(v<0){
return-1;
}
return 🔶️%StringLastIndexOf(y,w,v);
}

substring:

(L,M){
if((%IS_VAR(this)===null)||(this===(void 0)))🔶️throw 🔶️%make_type_error(17,"String.prototype.subString");
var p=(🔶️%_ToString(this));
var Z=p.length;
var aa=(🔶️%_ToInteger(L));
if(aa<0){
aa=0;
}else if(aa>Z){
aa=Z;
}
var ab=Z;
if(!(M===(void 0))){
ab=(🔶️%_ToInteger(M));
if(ab>Z){
ab=Z;
}else{
if(ab<0)ab=0;
if(aa>ab){
var ah=ab;
ab=aa;
aa=ah;
}
}
}
return 🔶️%_SubString(p,aa,ab);
}

⛔ slice (deoptimizated):

(L,M){
if((%IS_VAR(this)===null)||(this===(void 0)))🔶️throw 🔶️%make_type_error(17,"String.prototype.slice");
var p=(🔶️%_ToString(this));
var Z=p.length;
var aa=(🔶️%_ToInteger(L));
var ab=Z;
if(!(M===(void 0))){
ab=(🔶️%_ToInteger(M));
}
if(aa<0){
aa+=Z;
if(aa<0){
aa=0;
}
}else{
if(aa>Z){
return'';
}
}
if(ab<0){
ab+⚠️=Z;
if(ab⚠️<0){
return'';
}
}else{
if(ab>Z){
ab=Z;
}
}
if(ab<=aa){
return'';
}
return 🔶️%_SubString(p,aa,ab);
}
- Deopt: <JS Function isWhiteSpaceSingleLine (SharedFunctionInfo 0x30d407fdb0f1)> (opt #93) @1, FP to SP delta: 24, caller sp: 0x7fff5fbfd2e8

substr:

(L,Q){
if((%IS_VAR(this)===null)||(this===(void 0)))🔶️throw 🔶️%make_type_error(17,"String.prototype.substr");
var p=(🔶️%_ToString(this));
var ai=p⚠️.length;
L=(🔶️%_ToInteger(L));
Q=(Q===(void 0))?ai:(🔶️%_ToInteger(Q));
if(L<0)L=🔶️g(ai⚠️+L,0);
Q=🔷h(🔷g(Q,0),ai-L);
if(Q<=0)return'';
return 🔶️%_SubString(p,L,L+Q);
}
Inlined functions:
g
(k,l){
return k>l?k:l;
}
h
(k,l){
return k>l?l:k;
}

split:

~recompile~
~recompile~
(ac,ad){
if((%IS_VAR(this)===null)||(this===(void 0)))🔶️throw 🔶️%make_type_error(17,"String.prototype.split");
if(!(ac==null)){
var ae=ac⚠️[m];
if(!(ae===(void 0))){
return 🔶️%_Call(ae,ac,this,ad);
}
}
var u=(🔶️%_ToString(this));
ad=((ad===(void 0)))?4294967295:((ad)>>>0);
var Q=u.length;
var af=(🔶️%_ToString(ac));
if(ad===0)return🔶️[];
if((ac===(void 0)))return⚠️[u];
var ag=af.length;
if(ag===0)return 🔶️%StringToArray(u,ad);
return 🔶️%StringSplit(u,af,ad);
}

fs.js:

fs.Stats._checkModeProperty:

(property) {
  return ((this.mode & constants.S_IFMT) === property);
}

nullCheck:

(path, callback) {
  if (('' + path).🔶indexOf('\x5cu0000') !== -1) {
    var er🔶️ = new Error('Path must be a string without null bytes');
    er.co⚠️de = 'ENOENT';
    if (typeof callback !== 'function')
   🔶️   throw er;
    proce🔶️ss.nextTick(callback, er);
    return false;
  }
  return true;
}

fs.Stats:

(
    dev,
    mode,
    nlink,
    uid,
    gid,
    rdev,
    blksize,
    ino,
    size,
    blocks,
    atim_msec,
    mtim_msec,
    ctim_msec,
    birthtim_msec) {
  this.dev = dev;
  this.mode = mode;
  this.nlink = nlink;
  this.uid = uid;
  this.gid = gid;
  this.rdev = rdev;
  this.blksize = blksize;
  this.ino = ino;
  this.size = size;
  this.blocks = blocks;
  this.atime = 🔶️new Date(atim_msec);
  this.mtime = 🔶️new Date(mtim_msec);
  this.ctime = 🔶️new Date(ctim_msec);
  this.birthtime = 🔶️new Date(birthtim_msec);
}

fs.Stats.isFile:

() {
  return this.🔷_checkModeProperty(constants.S_IFREG);
}
Inlined functions:
_checkModeProperty
(property) {
  return ((this.mode & constants.S_IFMT) === property);
}

fs.statSync:

(path) {
  🔷nullCheck(path);
  return binding.🔶️stat(pathModule.🔶_makeLong(path));
}
Inlined functions:
nullCheck
(path, callback) {
  if (('' + path).🔶indexOf('\x5cu0000') !== -1) {
    var er🔶️ = new Error('Path must be a string without null bytes');
    er.co⚠️de = 'ENOENT';
    if (typeof callback !== 'function')
   🔶️   throw er;
    proce🔶️ss.nextTick(callback, er);
    return false;
  }
  return true;
}

fs.lstatSync:

(path) {
  🔷nullCheck(path);
  return binding.🔶️lstat(pathModule.🔶_makeLong(path));
}
Inlined functions:
nullCheck
(path, callback) {
  if (('' + path).🔶indexOf('\x5cu0000') !== -1) {
    var er🔶️ = new Error('Path must be a string without null bytes');
    er.co⚠️de = 'ENOENT';
    if (typeof callback !== 'function')
   🔶️   throw er;
    proce🔶️ss.nextTick(callback, er);
    return false;
  }
  return true;
}

fs.Stats.isSymbolicLink:

() {
  return this.🔷_checkModeProperty(constants.S_IFLNK);
}
Inlined functions:
_checkModeProperty
(property) {
  return ((this.mode & constants.S_IFMT) === property);
}

fs.Stats.isDirectory:

() {
  return this.🔷_checkModeProperty(constants.S_IFDIR);
}
Inlined functions:
_checkModeProperty
(property) {
  return ((this.mode & constants.S_IFMT) === property);
}

fs.openSync:

(path, flags, mode) {
  mode = 🔷modeNum(mode, 0o666);
  🔷nullCheck(path);
  return binding.🔶️open(pathModule.🔶_makeLong(path), 🔶️stringToFlags(flags), mode);
}
Inlined functions:
modeNum
(m, def) {
  if (typeof m === 'number')
    return m;
  if (typeof m === 'string')
    return 🔶️parseInt(m, 8);
  if (def)
    return 🔶modeNum(def);
  return undefined;
}
nullCheck
(path, callback) {
  if (('' + path).🔶indexOf('\x5cu0000') !== -1) {
    var er🔶️ = new Error('Path must be a string without null bytes');
    er.co⚠️de = 'ENOENT';
    if (typeof callback !== 'function')
   🔶️   throw er;
    proce🔶️ss.nextTick(callback, er);
    return false;
  }
  return true;
}

fs.fstatSync:

(fd) {
  return binding.🔶️fstat(fd);
}

fs.closeSync:

(fd) {
  return binding.🔶️close(fd);
}

getOptions:

(options, defaultOptions) {
  if (options === null || options === undefined ||
      typeof options === 'function') {
    return defaultOptions;
  }

  if (typeof options === 'string') {
    defaultOptions = util.🔷_extend({}, defaultOptions);
    defaultOptions.encoding = options;
    options = defaultOptions;
  } else if (typeof options !== 'object') {
    🔶️throw 🔶️new TypeError('"options" must be a string or an object, got ' +
                        typeof options + ' instead.');
  }

  if (options.encoding ⚠️!== 'buffer')
    🔷assertEncoding(options.encoding);
  return options;
}
Inlined functions:
_extend
(target, source) {
  // Don't do anything if source isn't an object
  if (source === null || typeof source !== 'object') return target;

var keys = Object.keys(source); var i = keys.length; while (i--) { target[keys[i]] ⚠️= source⚠️[keys[i]]; } return target; }

assertEncoding
(encoding) {
  if (encoding && !Buffer.🔷isEncoding(encoding)) {
    🔶️throw 🔶️new Error(`Unknown encoding: ${🔶️encoding}`);
  }
}
Inlined functions:
isEncoding
(encoding) {
  return typeof encoding === 'string' &&
         typeof internalUtil.🔷normalizeEncoding(encoding) === 'string';
}
Inlined functions:
normalizeEncoding
(enc) {
  if (!enc) return 'utf8';
  var low;
  for (;;) {
    ⚠️switch (enc) {
      case 'utf8':
      case 'utf-8':
        return 'utf8';
      case 'ucs2':
      case 'utf16le':
      case 'ucs-2':
      case 'utf-16le':
        return 'utf16le';
      case 'binary':
        return 'latin1';
      case 'base64':
      case 'ascii':
      case 'latin1':
      case 'hex':
        return enc;
      default:
        if (low) return; // undefined
        enc = ('' + enc).🔶️toLowerCase();
        low = true;
    }
  }
}

realpathSync:

(p, options) {
  options = 🔷getOptions(options, {});
  🔷nullCheck(p);

  p = p.toString('utf8');
  p = pathModule.resolve(p);

  const seenLinks = {};
  const knownHard = {};
  const cache = options[internalFS.realpathCacheKey];
  const original = p;

  const maybeCachedResult = cache && cache.get(p);
  if (maybeCachedResult) {
    return maybeCachedResult;
  }

  // current character position in p
  var pos;
  // the partial path so far, including a trailing slash if any
  var current;
  // the partial path without a trailing slash (except when pointing at a root)
  var base;
  // the partial path scanned in the previous round, with slash
  var previous;

  start();

  function start() {
    // Skip over roots
    var m = splitRootRe.exec(p);
    pos = m[0].length;
    current = m[0];
    base = m[0];
    previous = '';

    // On windows, check that the root exists. On unix there is no need.
    if (isWindows && !knownHard[base]) {
      fs.lstatSync(base);
      knownHard[base] = true;
    }
  }

  // walk down the path, swapping out linked pathparts for their real
  // values
  // NB: p.length changes.
  while (pos < p.length) {
    // find the next part
    nextPartRe.lastIndex = pos;
    var result = nextPartRe.exec(p);
    previous = current;
    current += result[0];
    base = previous + result[1];
    pos = nextPartRe.lastIndex;

    // continue if not a symlink
    if (knownHard[base] || (cache && cache.get(base) === base)) {
      continue;
    }

    var resolvedLink;
    const maybeCachedResolved = cache && cache.get(base);
    if (maybeCachedResolved) {
      resolvedLink = maybeCachedResolved;
    } else {
      var stat = fs.🔷lstatSync(base);
      if (!stat.🔷isSymbolicLink()) {
        knownHard[base] = true;
        continue;
      }

      // read the link if it wasn't read before
      // dev/ino always return 0 on windows, so skip the check.
      let linkTarget = null;
      let id;
      if (!isWindows) {
        id = `${stat.dev.toString(32)}:${stat.ino.toString(32)}`;
        if (seenLinks.hasOwnProperty(id)) {
          linkTarget = seenLinks[id];
        }
      }
      if (linkTarget === null) {
        fs.🔷statSync(base);
        linkTarget = fs.readlinkSync(base);
      }
      resolvedLink = pathModule.resolve(previous, linkTarget);

      if (cache) cache.set(base, resolvedLink);
      if (!isWindows) seenLinks[id] = linkTarget;
    }

    // resolve the link, then start over
    p = pathModule.resolve(resolvedLink, p.slice(pos));
    start();
  }

  if (cache) cache.set(original, p);
  return encodeRealpathResult(p, options);
}
Inlined functions:
getOptions
(options, defaultOptions) {
  if (options === null || options === undefined ||
      typeof options === 'function') {
    return defaultOptions;
  }

if (typeof options === 'string') { defaultOptions = util.🔷_extend({}, defaultOptions); defaultOptions.encoding = options; options = defaultOptions; } else if (typeof options !== 'object') { throw new TypeError('"options" must be a string or an object, got ' + typeof options + ' instead.'); }

if (options.encoding !== 'buffer') 🔷assertEncoding(options.encoding); return options; }

Inlined functions:
_extend
(target, source) {
  // Don't do anything if source isn't an object
  if (source === null || typeof source !== 'object') return target;

var keys = Object.keys(source); var i = keys.length; while (i--) { target[keys[i]] = source[keys[i]]; } return target; }

assertEncoding
(encoding) {
  if (encoding && !Buffer.🔷isEncoding(encoding)) {
    throw new Error(`Unknown encoding: ${encoding}`);
  }
}
Inlined functions:
isEncoding
(encoding) {
  return typeof encoding === 'string' &&
         typeof internalUtil.🔷normalizeEncoding(encoding) === 'string';
}
Inlined functions:
normalizeEncoding
(enc) {
  if (!enc) return 'utf8';
  var low;
  for (;;) {
    switch (enc) {
      case 'utf8':
      case 'utf-8':
        return 'utf8';
      case 'ucs2':
      case 'utf16le':
      case 'ucs-2':
      case 'utf-16le':
        return 'utf16le';
      case 'binary':
        return 'latin1';
      case 'base64':
      case 'ascii':
      case 'latin1':
      case 'hex':
        return enc;
      default:
        if (low) return; // undefined
        enc = ('' + enc).toLowerCase();
        low = true;
    }
  }
}
nullCheck
(path, callback) {
  if (('' + path).indexOf('\x5cu0000') !== -1) {
    var er = new Error('Path must be a string without null bytes');
    er.code = 'ENOENT';
    if (typeof callback !== 'function')
      throw er;
    process.nextTick(callback, er);
    return false;
  }
  return true;
}
lstatSync
(path) {
  🔷nullCheck(path);
  return binding.lstat(pathModule._makeLong(path));
}
Inlined functions:
nullCheck
(path, callback) {
  if (('' + path).indexOf('\x5cu0000') !== -1) {
    var er = new Error('Path must be a string without null bytes');
    er.code = 'ENOENT';
    if (typeof callback !== 'function')
      throw er;
    process.nextTick(callback, er);
    return false;
  }
  return true;
}
isSymbolicLink
() {
  return this.🔷_checkModeProperty(constants.S_IFLNK);
}
Inlined functions:
_checkModeProperty
(property) {
  return ((this.mode & constants.S_IFMT) === property);
}
statSync
(path) {
  🔷nullCheck(path);
  return binding.stat(pathModule._makeLong(path));
}
Inlined functions:
nullCheck
(path, callback) {
  if (('' + path).indexOf('\x5cu0000') !== -1) {
    var er = new Error('Path must be a string without null bytes');
    er.code = 'ENOENT';
    if (typeof callback !== 'function')
      throw er;
    process.nextTick(callback, er);
    return false;
  }
  return true;
}

StatWatcher:

() {
  EventEmitter.🔶️call(this);

  var self = this;
  this._handle = 🔶️new binding.StatWatcher();

  // uv_fs_poll is a little more powerful than ev_stat but we curb it for
  // the sake of backwards compatibility
  var oldStatus = -1;

  this._handle.onchange ⚠️= function(current, previous, newStatus) {
    if (oldStatus === -1 &&
        newStatus === -1 &&
        current.nlink === previous.nlink) return;

    oldStatus = newStatus;
    self.emit('change', current, previous);
  };

  this._handle.onstop = 🔶️function() {
    process.nextTick(emitStop, self);
  };
}

StatWatcher.start:

(filename, persistent, interval) {
  🔷nullCheck(filename);
  this._handle.🔶️start(pathModule.🔶_makeLong(filename), persistent, interval);
}
Inlined functions:
nullCheck
(path, callback) {
  if (('' + path).🔶indexOf('\x5cu0000') !== -1) {
    var er🔶️ = new Error('Path must be a string without null bytes');
    er.co⚠️de = 'ENOENT';
    if (typeof callback !== 'function')
   🔶️   throw er;
    proce🔶️ss.nextTick(callback, er);
    return false;
  }
  return true;
}

⛔ modeNum (deoptimizated):

(m, def) {
  if (typeof m === 'number')
    return m;
  if (typeof m === 'string')
    return 🔶️parseInt(m, 8);
  if (def)
    return 🔶modeNum(def);
  return undefined;
}
- Deopt: <JS Function isConst (SharedFunctionInfo 0x30d407fdf7a1)> (opt #1166) @19, FP to SP delta: 168, caller sp: 0x7fff5fbfcfa8
- Deopt: <JS Function getCombinedModifierFlags (SharedFunctionInfo 0x30d407ff0881)> (opt #1184) @55, FP to SP delta: 136, caller sp: 0x7fff5fbfcf70

/Users/cevek/Dev/github/neotech-platform/frontend/node_modules/typescript/lib/tsc.js:

combinePaths:

~recompile~
~recompile~
(path1, path2) {
        if (!(path1 && path1.length))
            return path2;
        if (!(path2 && path2⚠️.length))
            return path1;
        if (🔶getRootLength(path2) !== 0)
            return path2;
        if (path1.charAt(path1.length - 1) === ts.directorySeparator)
            return path1 + path2;
        return path1 + ts.directorySeparator + path2;
    }

fileExtensionIs:

(path, extension) {
        return path.length > extension.length && 🔷endsWith(path, extension);
    }
Inlined functions:
endsWith
(str, suffix) {
        var expectedPos = str.length - suffix.length;
        return expectedPos >= 0 && str.🔶indexOf(suffix, expectedPos) === expectedPos;
    }

getRootLength:

~recompile~
~recompile~
(path) {
        if (path.🔶️charCodeAt(0) === 47) {
            if (path.🔶️charCodeAt(1) !== 47)
                return 1;
            var p1 = path.⚠️indexOf("/", 2);
            if (p1 < 0)
                return 2;
            var p2 = path.⚠️indexOf("/", p1 ⚠️+ 1);
            if (p2 < 0)
                return p1 ⚠️+ 1;
            return p2 ⚠️+ 1;
        }
        if (path.charCodeAt(1) === 58) {
            if (path.⚠️charCodeAt(2) ⚠️=== 47)
                return 3;
            return 2;
        }
        if (path.🔶lastIndexOf("file:///", 0) === 0) {
            return "file:///".length;
        }
        var idx = path.🔶indexOf("://");
        if (idx !== -1) {
            return idx ⚠️+ "://".length;
        }
        return 0;
    }

tryRemoveExtension:

(path, extension) {
        return 🔷fileExtensionIs(path, extension) ? 🔷removeExtension(path, extension) : undefined;
    }
Inlined functions:
fileExtensionIs
(path, extension) {
        return path.length > extension.length && 🔷endsWith(path, extension);
    }
Inlined functions:
endsWith
(str, suffix) {
        var expectedPos = str.length - suffix.length;
        return expectedPos >= 0 && str.🔶indexOf(suffix, expectedPos) === expectedPos;
    }
removeExtension
(path, extension) {
        return path.🔶substring(0, path.length - extension.length);
    }

adjustExtensionPriority:

(extensionPriority) {
        if (extensionPriority < 2) {
            return 0;
        }
        else if (extensionPriority < 5) {
            return 2;
        }
        else {
            return 5;
        }
    }

caseInsensitiveKeyMapper:

(key) {
        return key.🔶️toLowerCase();
    }

compareStringsCaseInsensitive:

(a, b) {
        return 🔷compareStrings(a, b, true);
    }
Inlined functions:
compareStrings
(a, b, ignoreCase) {
        if (a === b)
            return 0;
        if (a === undefined)
            return -1;
        if (b === undefined)
            return 1;
        if (ignoreCase) {
            if (ts.collator && String.prototype.localeCompare) {
                var result = a.🔶️localeCompare(b, undefined, { usage: "sort", sensitivity: "accent" });
                return result < 0 ? -1 : result > 0 ? 1 : 0;
            }
            a = a.🔶️toUpperCase();
            b = b.🔶️toUpperCase();
            if (a ⚠️=== b)
                return 0;
        }
        return a ⚠️< b ? -1 : 1;
    }

isLineBreak:

(ch) {
        return ch === 10 ||
            ch === 13 ||
            ch === 8232 ||
            ch === 8233;
    }

token:

() {
            return currentToken;
        }

getStartPos:

() { return startPos; }

isIdentifierPart:

(ch, languageVersion) {
        return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 ||
            ch >= 48 && ch <= 57 || ch === 36 || ch === 95 ||
            ch > 127 && 🔶️isUnicodeIdentifierPart(ch, languageVersion);
    }

getIdentifierToken:

() {
            var len = tokenValue.length;
            if (len >= 2 && len <= 11) {
                var ch = tokenValue.charCodeAt(0);
                if (ch >= 97 && ch <= 122 && hasOwnProperty.🔶️call(textToToken, tokenValue)) {
                    return token = textToToken⚠️[tokenValue];
                }
            }
            return token = 70;
        }

nextToken:

() {
            return currentToken = scanner.🔶scan();
        }

scan:

~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
() {
            startPos = pos;
            hasExtendedUnicodeEscape = false;
            precedingLineBreak = false;
            tokenIsUnterminated = false;
            while (true) {
                tokenPos = pos;
                if (pos >= end) {
                    return token = 1;
                }
                var ch = text.charCodeAt(pos);
                if (ch === 35 && pos ⚠️=== 0 && 🔶️isShebangTrivia(text, pos)) {
                    pos = 🔶️scanShebangTrivia(text, pos);
                    if (skipTrivia) {
                        continue;
                    }
                    else {
                        return token = 6;
                    }
                }
                switch (ch) {
                    case 10:
                    case 13:
                        precedingLineBreak = true;
                        if (skipTrivia) {
                            pos++;
                            continue;
                        }
                        else {
                            if (ch === 13 && pos + 1 < end && text.charCodeAt(pos + 1) === 10) {
                                pos += 2;
                            }
                            else {
                                pos++;
                            }
                            return token = 4;
                        }
                    case 9:
                    case 11:
                    case 12:
                    case 32:
                        if (skipTrivia) {
                            pos++;
                            continue;
                        }
                        else {
                            while (pos < end && 🔷isWhiteSpaceSingleLine(text.charCodeAt(pos))) {
                                pos++;
                            }
                            return token = 5;
                        }
                    case 33:
                        if (text.charCodeAt(pos + 1) === 61) {
                            if (text.charCodeAt(pos + 2) === 61) {
                                return pos += 3, token = 34;
                            }
                            return pos += 2, token = 32;
                        }
                        pos++;
                        return token = 50;
                    case 34:
                    case 39:
                        tokenValue = 🔶scanString();
                        return token = 9;
                    case 96:
                        return token = 🔶️scanTemplateAndSetTokenValue();
                    case 37:
                        if (text.charCodeAt(pos + 1) === 61) {
                            return pos +⚠️= 2, token = 63;
                        }
                        pos++;
                        return token = 41;
                    case 38:
                        if (text.charCodeAt(pos + 1) === 38) {
                            return pos += 2, token = 52;
                        }
                        if (text.charCodeAt(pos + 1) === 61) {
                            return pos +⚠️= 2, token = 67;
                        }
                        pos++;
                        return token = 47;
                    case 40:
                        pos++;
                        return token = 18;
                    case 41:
                        pos++;
                        return token = 19;
                    case 42:
                        if (text.charCodeAt(pos + 1) === 61) {
                            return pos +⚠️= 2, token = 60;
                        }
                        if (text.charCodeAt(pos + 1) === 42) {
                            if (text.🔶️charCodeAt(pos ⚠️+ 2) ⚠️=== 61) {
                                return pos +⚠️= 3, token = 61;
                            }
                            return pos +⚠️= 2, token = 39;
                        }
                        pos++;
                        return token = 38;
                    case 43:
                        if (text.charCodeAt(pos + 1) === 43) {
                            return pos += 2, token = 42;
                        }
                        if (text.charCodeAt(pos + 1) === 61) {
                            return pos += 2, token = 58;
                        }
                        pos++;
                        return token = 36;
                    case 44:
                        pos++;
                        return token = 25;
                    case 45:
                        if (text.charCodeAt(pos + 1) === 45) {
                            return pos += 2, token = 43;
                        }
                        if (text.charCodeAt(pos + 1) === 61) {
                            return pos +⚠️= 2, token = 59;
                        }
                        pos++;
                        return token = 37;
                    case 46:
                        if (🔷isDigit(text.charCodeAt(pos + 1))) {
                            tokenValue = 🔶️scanNumber();
                            return token = 8;
                        }
                        if (text.charCodeAt(pos + 1) === 46 && text.charCodeAt(pos + 2) === 46) {
                            return pos += 3, token = 23;
                        }
                        pos++;
                        return token = 22;
                    case 47:
                        if (text.charCodeAt(pos + 1) === 47) {
                            pos += 2;
                            while (pos < end) {
                                if (🔷isLineBreak(text.charCodeAt(pos))) {
                                    break;
                                }
                                pos++;
                            }
                            if (skipTrivia) {
                                continue;
                            }
                            else {
                                return token = 2;
                            }
                        }
                        if (text.charCodeAt(pos + 1) === 42) {
                            pos += 2;
                            var commentClosed = false;
                            while (pos < end) {
                                var ch_2 = text.charCodeAt(pos);
                                if (ch_2 === 42 && text.charCodeAt(pos + 1) === 47) {
                                    pos += 2;
                                    commentClosed = true;
                                    break;
                                }
                                if (🔷isLineBreak(ch_2)) {
                                    precedingLineBreak = true;
                                }
                                pos++;
                            }
                            if (!commentClosed) {
                                🔶️error(ts⚠️.Diagnostics⚠️.Asterisk_Slash_expected);
                            }
                            if (skipTrivia) {
                                continue;
                            }
                            else {
                                tokenIsUnterminated = !commentClosed;
                                return token = 3;
                            }
                        }
                        if (text.charCodeAt(pos + 1) === 61) {
                            return pos +⚠️= 2, token = 62;
                        }
                        pos++;
                        return token = 40;
                    case 48:
                        if (pos + 2 < end && (text.charCodeAt(pos + 1) === 88 || text.charCodeAt(pos + 1) === 120)) {
                            pos +⚠️= 2;
                            var value = 🔶️scanMinimumNumberOfHexDigits(1);
                            if (value ⚠️< 0) {
                                🔶️error(ts⚠️.Diagnostics⚠️.Hexadecimal_digit_expected);
                                value = 0;
                            }
                            tokenValue = "" + value;
                            return token = 8;
                        }
                        else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 66 || text.charCodeAt(pos + 1) === 98)) {
                            pos +⚠️= 2;
                            var value = 🔶️scanBinaryOrOctalDigits(2);
                            if (value ⚠️< 0) {
                                🔶️error(ts⚠️.Diagnostics⚠️.Binary_digit_expected);
                                value = 0;
                            }
                            tokenValue = "" + value;
                            return token = 8;
                        }
                        else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 79 || text.charCodeAt(pos + 1) === 111)) {
                            pos +⚠️= 2;
                            var value = 🔶️scanBinaryOrOctalDigits(8);
                            if (value ⚠️< 0) {
                                🔶️error(ts⚠️.Diagnostics⚠️.Octal_digit_expected);
                                value = 0;
                            }
                            tokenValue = "" + value;
                            return token = 8;
                        }
                        if (pos + 1 < end && 🔷isOctalDigit(text.charCodeAt(pos + 1))) {
                            tokenValue = "" + 🔶️scanOctalDigits();
                            return token = 8;
                        }
                    case 49:
                    case 50:
                    case 51:
                    case 52:
                    case 53:
                    case 54:
                    case 55:
                    case 56:
                    case 57:
                        tokenValue = 🔶️scanNumber();
                        return token = 8;
                    case 58:
                        pos++;
                        return token = 55;
                    case 59:
                        pos++;
                        return token = 24;
                    case 60:
                        if (🔶isConflictMarkerTrivia(text, pos)) {
                            pos = 🔶️scanConflictMarkerTrivia(text, pos, error);
                            if (skipTrivia) {
                                continue;
                            }
                            else {
                                return token = 7;
                            }
                        }
                        if (text.charCodeAt(pos + 1) === 60) {
                            if (text.🔶️charCodeAt(pos ⚠️+ 2) ⚠️=== 61) {
                                return pos +⚠️= 3, token = 64;
                            }
                            return pos +⚠️= 2, token = 44;
                        }
                        if (text.charCodeAt(pos + 1) === 61) {
                            return pos += 2, token = 29;
                        }
                        if (languageVariant === 1 &&
                            text.charCodeAt(pos + 1) === 47 &&
                            text.🔶️charCodeAt(pos ⚠️+ 2) ⚠️!== 42) {
                            return pos +⚠️= 2, token = 27;
                        }
                        pos++;
                        return token = 26;
                    case 61:
                        if (🔶isConflictMarkerTrivia(text, pos)) {
                            pos = 🔶️scanConflictMarkerTrivia(text, pos, error);
                            if (skipTrivia) {
                                continue;
                            }
                            else {
                                return token = 7;
                            }
                        }
                        if (text.charCodeAt(pos + 1) === 61) {
                            if (text.charCodeAt(pos + 2) === 61) {
                                return pos += 3, token = 33;
                            }
                            return pos += 2, token = 31;
                        }
                        if (text.charCodeAt(pos + 1) === 62) {
                            return pos += 2, token = 35;
                        }
                        pos++;
                        return token = 57;
                    case 62:
                        if (🔶isConflictMarkerTrivia(text, pos)) {
                            pos = 🔶️scanConflictMarkerTrivia(text, pos, error);
                            if (skipTrivia) {
                                continue;
                            }
                            else {
                                return token = 7;
                            }
                        }
                        pos++;
                        return token = 28;
                    case 63:
                        pos++;
                        return token = 54;
                    case 91:
                        pos++;
                        return token = 20;
                    case 93:
                        pos++;
                        return token = 21;
                    case 94:
                        if (text.⚠️charCodeAt(pos ⚠️+ 1) ⚠️=== 61) {
                            return pos +⚠️= 2, token = 69;
                        }
                        pos++;
                        return token = 49;
                    case 123:
                        pos++;
                        return token = 16;
                    case 124:
                        if (text.charCodeAt(pos + 1) === 124) {
                            return pos += 2, token = 53;
                        }
                        if (text.charCodeAt(pos + 1) === 61) {
                            return pos +⚠️= 2, token = 68;
                        }
                        pos++;
                        return token = 48;
                    case 125:
                        pos++;
                        return token = 17;
                    case 126:
                        pos++;
                        return token = 51;
                    case 64:
                        pos++;
                        return token = 56;
                    case 92:
                        var cookedChar = 🔶️peekUnicodeEscape();
                        if (cookedChar >= 0 && 🔶isIdentifierStart(cookedChar, languageVersion)) {
                            pos +⚠️= 6;
                            tokenValue = String.fromCharCode(cookedChar) ⚠️+ scanIdentifierParts();
                            return token = 🔶getIdentifierToken();
                        }
                        🔶️error(ts⚠️.Diagnostics⚠️.Invalid_character);
                        pos++;
                        return token = 0;
                    default:
                        if (🔷isIdentifierStart(ch, languageVersion)) {
                            pos++;
                            while (pos < end && 🔷isIdentifierPart(ch = text.charCodeAt(pos), languageVersion))
                                pos++;
                            tokenValue = text.🔶substring(tokenPos, pos);
                            if (ch === 92) {
                                tokenValue +⚠️= scanIdentifierParts();
                            }
                            return token = 🔶getIdentifierToken();
                        }
                        else if (🔶isWhiteSpaceSingleLine(ch)) {
                            pos++;
                            continue;
                        }
                        else if (🔶isLineBreak(ch)) {
                            precedingLineBreak = true;
                            pos++;
                            continue;
                        }
                        🔶️error(ts⚠️.Diagnostics⚠️.Invalid_character);
                        pos++;
                        return token = 0;
                }
            }
        }
Inlined functions:
isWhiteSpaceSingleLine
(ch) {
        return ch === 32 ||
            ch === 9 ||
            ch === 11 ||
            ch === 12 ||
            ch === 160 ||
            ch === 133 ||
            ch === 5760 ||
            ch >= 8192 && ch <= 8203 ||
            ch === 8239 ||
            ch === 8287 ||
            ch === 12288 ||
            ch === 65279;
    }
isDigit
(ch) {
        return ch >= 48 && ch <= 57;
    }
isLineBreak
(ch) {
        return ch === 10 ||
            ch === 13 ||
            ch === 8232 ||
            ch === 8233;
    }
isLineBreak
(ch) {
        return ch === 10 ||
            ch === 13 ||
            ch === 8232 ||
            ch === 8233;
    }
isOctalDigit
(ch) {
        return ch >= 48 && ch <= 55;
    }
isIdentifierStart
(ch, languageVersion) {
        return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 ||
            ch === 36 || ch === 95 ||
            ch > 127 && 🔷isUnicodeIdentifierStart(ch, languageVersion);
    }
Inlined functions:
isUnicodeIdentifierStart
(code, languageVersion) {
        return languageVersion >= 1 ?
            🔷lookupInUnicodeMap(code, unicodeES5IdentifierStart) :
            🔶️lookupInUnicodeMap(code, unicodeES3IdentifierStart);
    }
Inlined functions:
lookupInUnicodeMap
(code, map) {
        if (code < map[0]) {
            return false;
        }
        var lo = 0;
        var hi = map.length;
        var mid;
        while (lo + 1 < hi) {
            mid = lo + (hi - lo) / 2;
            mid -= mid % 2;
            if (map[mid] <= code && code <= map[mid + 1]) {
                return true;
            }
            if (code < map[mid]) {
                hi = mid;
            }
            else {
                lo = mid + 2;
            }
        }
        return false;
    }
isIdentifierPart
(ch, languageVersion) {
        return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 ||
            ch >= 48 && ch <= 57 || ch === 36 || ch === 95 ||
            ch > 127 && 🔷isUnicodeIdentifierPart(ch, languageVersion);
    }
Inlined functions:
isUnicodeIdentifierPart
(code, languageVersion) {
        return languageVersion >= 1 ?
            🔷lookupInUnicodeMap(code, unicodeES5IdentifierPart) :
            🔶️lookupInUnicodeMap(code, unicodeES3IdentifierPart);
    }
Inlined functions:
lookupInUnicodeMap
(code, map) {
        if (code < map[0]) {
            return false;
        }
        var lo = 0;
        var hi = map.length;
        var mid;
        while (lo + 1 < hi) {
            mid = lo + (hi - lo) / 2;
            mid -= mid % 2;
            if (map[mid] <= code && code <= map[mid + 1]) {
                return true;
            }
            if (code < map[mid]) {
                hi = mid;
            }
            else {
                lo = mid + 2;
            }
        }
        return false;
    }

inDecoratorContext:

() {
            return 🔷inContext(8192);
        }
Inlined functions:
inContext
(flags) {
            return (contextFlags & flags) !== 0;
        }

Node:

(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

createNode:

~recompile~
~recompile~
(kind, location, flags) {
        var ConstructorForKind = kind === 261
            ? (SourceFileConstructor || (SourceFileConstructor = ts⚠️.objectAllocator.🔶getSourceFileConstructor()))
            : (NodeConstructor || (NodeConstructor = ts⚠️.objectAllocator.🔶getNodeConstructor()));
        var node = location
            ? 🔷new ConstructorForKind(kind, location⚠️.pos, location⚠️.end)
            : 🔷new ConstructorForKind(kind, -1, -1);
        node.flags = flags | 8;
        return node;
    }
Inlined functions:
new ConstructorForKind
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new ConstructorForKind
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

⛔ finishNode (deoptimizated):

~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }
- Deopt: <JS Function addJSDocComment (SharedFunctionInfo 0x98bdb9c5db9)> (opt #372) @15, FP to SP delta: 48, caller sp: 0x7fff5fbfd2b0
- Deopt: <JS Function parseList (SharedFunctionInfo 0x98bdb9c95f9)> (opt #272) @21, FP to SP delta: 80, caller sp: 0x7fff5fbfd5d0

parseOptional:

(t) {
            if (🔷token() === t) {
                🔷nextToken();
                return true;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }

createNodeArray:

~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
(elements, location, hasTrailingComma) {
        if (elements) {
            if (ts.🔷isNodeArray(elements)) {
                return elements;
            }
        }
        else {
            elements = [];
        }
        var array = elements;
        if (location) {
            array.pos ⚠️= location⚠️.pos;
            array.end = location⚠️.end;
        }
        else {
            array.pos ⚠️= -1;
            array.end = -1;
        }
        if (hasTrailingComma) {
            array.hasTrailingComma = true;
        }
        return array;
    }
Inlined functions:
isNodeArray
(array) {
        return array.🔶️hasOwnProperty("pos")
            && array.🔶️hasOwnProperty("end");
    }

getTokenValue:

() { return tokenValue; }

isIdentifier:

~recompile~
~recompile~
~recompile~
(node) {
        return node⚠️.kind === 70;
    }

escapeIdentifier:

~recompile~
~recompile~
(identifier) {
        return identifier⚠️.length >= 2 && identifier.🔶️charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 ? "_" + identifier : identifier;
    }

getTokenPos:

() { return tokenPos; }

createIdentifier:

~recompile~
~recompile~
~recompile~
(text, location) {
        var node = 🔷createNode(70, location);
        node.text = ts.🔷escapeIdentifier(text);
        node.originalKeywordKind = ts.🔷stringToToken(text);
        node.autoGenerateKind = 0;
        node.autoGenerateId = 0;
        return node;
    }
Inlined functions:
createNode
(kind, location, flags) {
        var ConstructorForKind = kind === 261
            ? (SourceFileConstructor || (SourceFileConstructor = ts⚠️.objectAllocator.🔶getSourceFileConstructor()))
            : (NodeConstructor || (NodeConstructor = ts⚠️.objectAllocator.🔶getNodeConstructor()));
        var node = location
            ? 🔷new ConstructorForKind(kind, location⚠️.pos, location⚠️.end)
            : 🔷new ConstructorForKind(kind, -1, -1);
        node.flags = flags | 8;
        return node;
    }
Inlined functions:
new ConstructorForKind
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new ConstructorForKind
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
escapeIdentifier
(identifier) {
        return identifier⚠️.length >= 2 && identifier.🔶️charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 ? "_" + identifier : identifier;
    }
stringToToken
(s) {
        return textToToken⚠️[s];
    }

getNodeEnd:

() {
            return scanner.🔶getStartPos();
        }

⛔ speculationHelper (deoptimizated):

~recompile~
~recompile~
(callback, isLookahead) {
            var savePos = pos;
            var saveStartPos = startPos;
            var saveTokenPos = tokenPos;
            var saveToken = token;
            var saveTokenValue = tokenValue;
            var savePrecedingLineBreak = precedingLineBreak;
            var result = 🔶️callback();
            if (!result || isLookahead) {
                pos = savePos;
                startPos = saveStartPos;
                tokenPos = saveTokenPos;
                token = saveToken;
                tokenValue = saveTokenValue;
                precedingLineBreak = savePrecedingLineBreak;
            }
            return result;
        }
- Deopt: <JS Function findSourceFile (SharedFunctionInfo 0x3901d38f6429)> (opt #361) @34, FP to SP delta: 96, caller sp: 0x7fff5fbfdf90

isModifierKind:

(token) {
        switch (token) {
            case 116:
            case 119:
            case 75:
            case 123:
            case 78:
            case 83:
            case 113:
            case 111:
            case 112:
            case 130:
            case 114:
                return true;
        }
        return false;
    }

parseTypeOperatorOrHigher:

() {
            switch (🔷token()) {
                case 126:
                    return 🔶parseTypeOperator(126);
            }
            return 🔶parseArrayTypeOrHigher();
        }
Inlined functions:
token
() {
            return currentToken;
        }

parseIntersectionTypeOrHigher:

~recompile~
~recompile~
~recompile~
~recompile~
() {
            return 🔷parseUnionOrIntersectionType(165, parseTypeOperatorOrHigher, 47);
        }
Inlined functions:
parseUnionOrIntersectionType
(kind, parseConstituentType, operator) {
            🔷parseOptional(operator);
            var type = 🔶️parseConstituentType();
            if (🔷token() === operator) {
                var types = 🔷createNodeArray([type], type⚠️.pos);
                while (🔷parseOptional(operator)) {
                    types.push(🔶️parseConstituentType());
                }
                types.end = 🔷getNodeEnd();
                var node = 🔷createNode(kind, type⚠️.pos);
                node.types = types;
                type = 🔷finishNode(node);
            }
            return type;
        }
Inlined functions:
parseOptional
(t) {
            if (🔷token() === t) {
                🔷nextToken();
                return true;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
token
() {
            return currentToken;
        }
createNodeArray
(elements, pos) {
            var array = (elements || []);
            if (!(pos >= 0)) {
                pos = 🔷getNodePos();
            }
            array.pos ⚠️= pos;
            array.end = pos;
            return array;
        }
Inlined functions:
getNodePos
() {
            return scanner.🔶getStartPos();
        }
parseOptional
(t) {
            if (🔷token() === t) {
                🔷nextToken();
                return true;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
getNodeEnd
() {
            return scanner.🔶getStartPos();
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }

parseType:

() {
            return 🔷doOutsideOfContext(20480, parseTypeWorker);
        }
Inlined functions:
doOutsideOfContext
(context, func) {
            var contextFlagsToClear = context & contextFlags;
            if (contextFlagsToClear) {
                🔶setContextFlag(false, contextFlagsToClear);
                var result = 🔶️func();
                🔶setContextFlag(true, contextFlagsToClear);
                return result;
            }
            return 🔶️func();
        }

parseTypeWorker:

~recompile~
~recompile~
~recompile~
() {
            if (🔷isStartOfFunctionType()) {
                return 🔷parseFunctionOrConstructorType(158);
            }
            if (🔶token() === 93) {
                return 🔶️parseFunctionOrConstructorType(159);
            }
            return 🔶parseUnionTypeOrHigher();
        }
Inlined functions:
isStartOfFunctionType
() {
            if (🔷token() === 26) {
                return true;
            }
            return 🔷token() === 18 && 🔷lookAhead(isUnambiguouslyStartOfFunctionType);
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
lookAhead
(callback) {
            return 🔶speculationHelper(callback, true);
        }
parseFunctionOrConstructorType
(kind) {
            var node = 🔷createNode(kind);
            if (kind === 159) {
                🔷parseExpected(93);
            }
            🔶fillSignature(35, false, false, false, node);
            return 🔷finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }

isStartOfFunctionType:

() {
            if (🔷token() === 26) {
                return true;
            }
            return 🔷token() === 18 && 🔷lookAhead(isUnambiguouslyStartOfFunctionType);
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
lookAhead
(callback) {
            return 🔶speculationHelper(callback, true);
        }

parseExpected:

~recompile~
~recompile~
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

hasPrecedingLineBreak:

() { return precedingLineBreak; }

parseOptionalToken:

~recompile~
~recompile~
~recompile~
(t) {
            if (🔷token() === t) {
                return 🔷parseTokenNode();
            }
            return undefined;
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔷nextToken();
            return 🔷finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }

iterateCommentRanges:

~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
(reduce, text, pos, trailing, cb, state, initial) {
        var pendingPos;
        var pendingEnd;
        var pendingKind;
        var pendingHasTrailingNewLine;
        var hasPendingCommentRange = false;
        var collecting = trailing || pos === 0;
        var accumulator = initial;
        scan: while (pos >= 0 && pos < text.length) {
            var ch = text.charCodeAt(pos);
            switch (ch) {
                case 13:
                    if (text.charCodeAt(pos + 1) === 10) {
                        pos++;
                    }
                case 10:
                    pos++;
                    if (trailing) {
                        break scan;
                    }
                    collecting = true;
                    if (hasPendingCommentRange) {
                        pendingHasTrailingNewLine = true;
                    }
                    continue;
                case 9:
                case 11:
                case 12:
                case 32:
                    pos++;
                    continue;
                case 47:
                    var nextChar = text.charCodeAt(pos + 1);
                    var hasTrailingNewLine = false;
                    if (nextChar === 47 || nextChar === 42) {
                        var kind = nextChar === 47 ? 2 : 3;
                        var startPos = pos;
                        pos += 2;
                        if (nextChar === 47) {
                            while (pos < text.length) {
                                if (🔷isLineBreak(text.charCodeAt(pos))) {
                                    hasTrailingNewLine = true;
                                    break;
                                }
                                pos++;
                            }
                        }
                        else {
                            while (pos < text.length) {
                                if (text.charCodeAt(pos) === 42 && text.charCodeAt(pos + 1) === 47) {
                                    pos += 2;
                                    break;
                                }
                                pos++;
                            }
                        }
                        if (collecting) {
                            if (hasPendingCommentRange) {
                                accumulator = 🔶️cb(pendingPos, pendingEnd, pendingKind, pendingHasTrailingNewLine, state, accumulator);
                                if (!reduce && accumulator) {
                                    return accumulator;
                                }
                                hasPendingCommentRange = false;
                            }
                            pendingPos = startPos;
                            pendingEnd = pos;
                            pendingKind = kind;
                            pendingHasTrailingNewLine = hasTrailingNewLine;
                            hasPendingCommentRange = true;
                        }
                        continue;
                    }
                    break scan;
                default:
                    if (ch > 127 && (🔶isWhiteSpace(ch))) {
                        if (hasPendingCommentRange && 🔶isLineBreak(ch)) {
                            pendingHasTrailingNewLine = true;
                        }
                        pos++;
                        continue;
                    }
                    break scan;
            }
        }
        if (hasPendingCommentRange) {
            accumulator = 🔶️cb(pendingPos, pendingEnd, pendingKind, pendingHasTrailingNewLine, state, accumulator);
        }
        return accumulator;
    }
Inlined functions:
isLineBreak
(ch) {
        return ch === 10 ||
            ch === 13 ||
            ch === 8232 ||
            ch === 8233;
    }

parseIdentifier:

~recompile~
~recompile~
~recompile~
(diagnosticMessage) {
            return 🔷createIdentifier(🔷isIdentifier(), diagnosticMessage);
        }
Inlined functions:
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
createIdentifier
(isIdentifier, diagnosticMessage) {
            identifierCount++;
            if (isIdentifier) {
                var node = 🔷createNode(70);
                if (🔷token() !== 70) {
                    node.originalKeywordKind = 🔷token();
                }
                node.text = 🔷internIdentifier(scanner.getTokenValue());
                🔷nextToken();
                return 🔷finishNode(node);
            }
            return 🔷createMissingNode(70, false, diagnosticMessage || ts⚠️.Diagnostics⚠️.Identifier_expected);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
internIdentifier
(text) {
            text = ts.🔷escapeIdentifier(text);
            return identifiers⚠️[text] || (identifiers[text] ⚠️= text);
        }
Inlined functions:
escapeIdentifier
(identifier) {
        return identifier⚠️.length >= 2 && identifier.🔶️charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 ? "_" + identifier : identifier;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }
createMissingNode
(kind, reportAtCurrentPosition, diagnosticMessage, arg0) {
            if (reportAtCurrentPosition) {
                🔶️parseErrorAtPosition(scanner.🔶getStartPos(), 0, diagnosticMessage, arg0);
            }
            else {
                🔷parseErrorAtCurrentToken(diagnosticMessage, arg0);
            }
            var result = 🔶createNode(kind, scanner.🔶getStartPos());
            result.text = "";
            return 🔶finishNode(result);
        }
Inlined functions:
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

setContextFlag:

~recompile~
~recompile~
(val, flag) {
            if (val) {
                contextFlags |= flag;
            }
            else {
                contextFlags &= ~flag;
            }
        }

isListElement:

~recompile~
~recompile~
~recompile~
~recompile~
(parsingContext, inErrorRecovery) {
            var node = 🔶currentNode(parsingContext);
            if (node) {
                return true;
            }
            ⚠️switch (parsingContext) {
                case 0:
                case 1:
                case 3:
                    return !(🔷token() === 24 && inErrorRecovery) && 🔶isStartOfStatement();
                case 2:
                    return 🔶token() ⚠️=== 72 || 🔶token() ⚠️=== 78;
                case 4:
                    return 🔷lookAhead(isTypeMemberStart);
                case 5:
                    return 🔷lookAhead(isClassMemberStart) || (🔷token() === 24 && !inErrorRecovery);
                case 6:
                    return 🔷token() === 20 || 🔷isLiteralPropertyName();
                case 12:
                    return 🔷token() === 20 || 🔷token() === 38 || 🔷token() === 23 || 🔷isLiteralPropertyName();
                case 17:
                    return 🔶isLiteralPropertyName();
                case 9:
                    return 🔷token() === 20 || 🔷token() === 23 || 🔷isLiteralPropertyName();
                case 7:
                    if (🔷token() === 16) {
                        return 🔶lookAhead(isValidHeritageClauseObjectLiteral);
                    }
                    if (!inErrorRecovery) {
                        return 🔶isStartOfLeftHandSideExpression() && !🔷isHeritageClauseExtendsOrImplementsKeyword();
                    }
                    else {
                        return 🔶isIdentifier() && !🔶️isHeritageClauseExtendsOrImplementsKeyword();
                    }
                case 8:
                    return 🔷isIdentifierOrPattern();
                case 10:
                    return 🔷token() === 25 || 🔷token() === 23 || 🔷isIdentifierOrPattern();
                case 18:
                    return 🔷isIdentifier();
                case 11:
                case 15:
                    return 🔷token() === 25 || 🔷token() === 23 || 🔶isStartOfExpression();
                case 16:
                    return 🔷isStartOfParameter();
                case 19:
                case 20:
                    return 🔶token() === 25 || 🔶isStartOfType();
                case 21:
                    return 🔶isHeritageClause();
                case 22:
                    return ts.🔶tokenIsIdentifierOrKeyword(🔶token());
                case 13:
                    return ts.🔶tokenIsIdentifierOrKeyword(🔶token()) || 🔶token() === 16;
                case 14:
                    return true;
                case 23:
                case 24:
                case 26:
                    return JSDocParser.⚠️isJSDocType();
                case 25:
                    return 🔶️isSimplePropertyName();
            }
            ts⚠️.Debug.⚠️fail("Non-exhaustive case in 'isListElement'.");
        }
Inlined functions:
token
() {
            return currentToken;
        }
lookAhead
(callback) {
            return 🔶speculationHelper(callback, true);
        }
lookAhead
(callback) {
            return 🔶speculationHelper(callback, true);
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isLiteralPropertyName
() {
            return ts.🔷tokenIsIdentifierOrKeyword(🔷token()) ||
                🔷token() === 9 ||
                🔷token() === 8;
        }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isLiteralPropertyName
() {
            return ts.🔷tokenIsIdentifierOrKeyword(🔷token()) ||
                🔷token() === 9 ||
                🔷token() === 8;
        }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isLiteralPropertyName
() {
            return ts.🔷tokenIsIdentifierOrKeyword(🔷token()) ||
                🔷token() === 9 ||
                🔷token() === 8;
        }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isHeritageClauseExtendsOrImplementsKeyword
() {
            if (🔷token() === 107 ||
                🔷token() === 84) {
                return 🔶lookAhead(nextTokenIsStartOfExpression);
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isIdentifierOrPattern
() {
            return 🔷token() === 16 || 🔷token() === 20 || 🔷isIdentifier();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isIdentifierOrPattern
() {
            return 🔷token() === 16 || 🔷token() === 20 || 🔷isIdentifier();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isStartOfParameter
() {
            return 🔷token() === 23 || 🔷isIdentifierOrPattern() || ts.🔷isModifierKind(🔷token()) || 🔶token() === 56 || 🔶token() === 98;
        }
Inlined functions:
token
() {
            return currentToken;
        }
isIdentifierOrPattern
() {
            return 🔷token() === 16 || 🔷token() === 20 || 🔷isIdentifier();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isModifierKind
(token) {
        switch (token) {
            case 116:
            case 119:
            case 75:
            case 123:
            case 78:
            case 83:
            case 113:
            case 111:
            case 112:
            case 130:
            case 114:
                return true;
        }
        return false;
    }

parseListElement:

(parsingContext, parseElement) {
            var node = 🔶currentNode(parsingContext);
            if (node) {
                return 🔶️consumeNode(node);
            }
            return 🔶️parseElement();
        }

parseTypeReference:

~recompile~
~recompile~
() {
            var typeName = 🔷parseEntityName(false, ts.Diagnostics.Type_expected);
            var node = createNode(157, typeName.pos);
            node.typeName = typeName;
            if (!scanner.🔶hasPrecedingLineBreak() && 🔶token() === 26) {
                node.typeArguments = 🔶parseBracketedList(19, parseType, 26, 28);
            }
            return 🔶finishNode(node);
        }
Inlined functions:
parseEntityName
(allowReservedWords, diagnosticMessage) {
            var entity = 🔷parseIdentifier(diagnosticMessage);
            while (🔶parseOptional(22)) {
                var node = createNode(141, entity.pos);
                node.left = entity;
                node.right = 🔶parseRightSideOfDot(allowReservedWords);
                entity = 🔶finishNode(node);
            }
            return entity;
        }
Inlined functions:
parseIdentifier
(diagnosticMessage) {
            return 🔷createIdentifier(🔷isIdentifier(), diagnosticMessage);
        }
Inlined functions:
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
createIdentifier
(isIdentifier, diagnosticMessage) {
            identifierCount++;
            if (isIdentifier) {
                var node = 🔷createNode(70);
                if (🔷token() !== 70) {
                    node.originalKeywordKind = 🔷token();
                }
                node.text = 🔷internIdentifier(scanner.getTokenValue());
                🔷nextToken();
                return 🔷finishNode(node);
            }
            return 🔷createMissingNode(70, false, diagnosticMessage || ts⚠️.Diagnostics⚠️.Identifier_expected);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
internIdentifier
(text) {
            text = ts.🔷escapeIdentifier(text);
            return identifiers⚠️[text] || (identifiers[text] ⚠️= text);
        }
Inlined functions:
escapeIdentifier
(identifier) {
        return identifier⚠️.length >= 2 && identifier.charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 ? "_" + identifier : identifier;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }
createMissingNode
(kind, reportAtCurrentPosition, diagnosticMessage, arg0) {
            if (reportAtCurrentPosition) {
                🔶️parseErrorAtPosition(scanner.🔶getStartPos(), 0, diagnosticMessage, arg0);
            }
            else {
                🔷parseErrorAtCurrentToken(diagnosticMessage, arg0);
            }
            var result = 🔷createNode(kind, scanner.🔶getStartPos());
            result.text = "";
            return 🔶finishNode(result);
        }
Inlined functions:
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔶️parseErrorAtPosition(start, length, message, arg0);
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔶️new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔶️new IdentifierConstructor(kind, pos, pos) :
                    🔶️new TokenConstructor(kind, pos, pos);
        }

getLeadingCommentRanges:

(text, pos) {
        return 🔷reduceEachLeadingCommentRange(text, pos, appendCommentRange, undefined, undefined);
    }
Inlined functions:
reduceEachLeadingCommentRange
(text, pos, cb, state, initial) {
        return 🔶iterateCommentRanges(true, text, pos, false, cb, state, initial);
    }

parseBracketedList:

(kind, parseElement, open, close) {
            if (🔷parseExpected(open)) {
                var result = 🔶parseDelimitedList(kind, parseElement);
                🔷parseExpected(close);
                return result;
            }
            return 🔶️createMissingList();
        }
Inlined functions:
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts⚠️.Diagnostics⚠️._0_expected, ts.🔶tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔶lastOrUndefined(parseDiagnostics);
            if (!lastError || start ⚠️!== lastError⚠️.start) {
                parseDiagnostics.🔶️push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts⚠️.Diagnostics⚠️._0_expected, ts.🔶tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔶lastOrUndefined(parseDiagnostics);
            if (!lastError || start ⚠️!== lastError⚠️.start) {
                parseDiagnostics.🔶️push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }

isListTerminator:

~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
(kind) {
            if (🔷token() === 1) {
                return true;
            }
            switch (kind) {
                case 1:
                case 2:
                case 4:
                case 5:
                case 6:
                case 12:
                case 9:
                case 22:
                    return 🔷token() === 17;
                case 3:
                    return 🔶token() ⚠️=== 17 || 🔶token() ⚠️=== 72 || 🔶token() ⚠️=== 78;
                case 7:
                    return 🔷token() === 16 || 🔷token() === 84 || 🔷token() === 107;
                case 8:
                    return 🔷isVariableDeclaratorListTerminator();
                case 18:
                    return 🔷token() === 28 || 🔶token() ⚠️=== 18 || 🔶token() ⚠️=== 16 || 🔶token() ⚠️=== 84 || 🔶token() ⚠️=== 107;
                case 11:
                    return 🔷token() === 19 || 🔷token() === 24;
                case 15:
                case 20:
                case 10:
                    return 🔷token() === 21;
                case 16:
                case 17:
                    return 🔷token() === 19 || 🔷token() === 21;
                case 19:
                    return 🔷token() !== 25;
                case 21:
                    return 🔷token() === 16 || 🔷token() === 17;
                case 13:
                    return 🔷token() === 28 || 🔷token() === 40;
                case 14:
                    return 🔶token() ⚠️=== 26 && 🔶lookAhead(nextTokenIsSlash);
                case 23:
                    return 🔶token() ⚠️=== 19 || 🔶token() ⚠️=== 55 || 🔶token() ⚠️=== 17;
                case 24:
                    return 🔶token() ⚠️=== 28 || 🔶token() ⚠️=== 17;
                case 26:
                    return 🔶token() ⚠️=== 21 || 🔶token() ⚠️=== 17;
                case 25:
                    return 🔶token() ⚠️=== 17;
            }
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isVariableDeclaratorListTerminator
() {
            if (🔷canParseSemicolon()) {
                return true;
            }
            if (🔷isInOrOfKeyword(🔷token())) {
                return true;
            }
            if (🔷token() === 35) {
                return true;
            }
            return false;
        }
Inlined functions:
canParseSemicolon
() {
            if (🔷token() === 24) {
                return true;
            }
            return 🔷token() === 17 || 🔷token() === 1 || scanner.🔶hasPrecedingLineBreak();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isInOrOfKeyword
(t) {
            return t === 91 || t === 140;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

parseNonArrayType:

~recompile~
~recompile~
() {
            switch (🔷token()) {
                case 118:
                case 134:
                case 132:
                case 121:
                case 135:
                case 137:
                case 129:
                    var node = 🔷tryParse(parseKeywordAndNoDot);
                    return node || 🔶parseTypeReference();
                case 9:
                case 8:
                case 100:
                case 85:
                    return 🔷parseLiteralTypeNode();
                case 37:
                    return 🔶lookAhead(nextTokenIsNumericLiteral) ? 🔶️parseLiteralTypeNode() : 🔶parseTypeReference();
                case 104:
                case 94:
                    return 🔷parseTokenNode();
                case 98: {
                    var thisKeyword = 🔶parseThisTypeNode();
                    if (🔶token() === 125 && !scanner.⚠️hasPrecedingLineBreak()) {
                        return 🔶️parseThisTypePredicate(thisKeyword);
                    }
                    else {
                        return thisKeyword;
                    }
                }
                case 102:
                    return 🔶️parseTypeQuery();
                case 16:
                    return 🔶lookAhead(isStartOfMappedType) ? 🔶️parseMappedType() : 🔶parseTypeLiteral();
                case 20:
                    return 🔶️parseTupleType();
                case 18:
                    return 🔶️parseParenthesizedType();
                default:
                    return 🔶parseTypeReference();
            }
        }
Inlined functions:
token
() {
            return currentToken;
        }
tryParse
(callback) {
            return 🔶speculationHelper(callback, false);
        }
parseLiteralTypeNode
() {
            var node = 🔷createNode(171);
            node.literal = 🔶parseSimpleUnaryExpression();
            🔷finishNode(node);
            return node;
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔶nextToken();
            return 🔶finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

⛔ tokenIsIdentifierOrKeyword (deoptimizated):

(token) {
        return token >= 70;
    }
- Deopt: <JS Function iterateCommentRanges (SharedFunctionInfo 0x30d407fdb871)> (opt #65) @10, FP to SP delta: 128, caller sp: 0x7fff5fbfd670

isIdentifierStart:

(ch, languageVersion) {
        return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 ||
            ch === 36 || ch === 95 ||
            ch > 127 && 🔶️isUnicodeIdentifierStart(ch, languageVersion);
    }

setYieldContext:

(val) {
            🔷setContextFlag(val, 4096);
        }
Inlined functions:
setContextFlag
(val, flag) {
            if (val) {
                contextFlags |⚠️= flag;
            }
            else {
                contextFlags &= ~flag;
            }
        }

setAwaitContext:

(val) {
            🔷setContextFlag(val, 16384);
        }
Inlined functions:
setContextFlag
(val, flag) {
            if (val) {
                contextFlags |⚠️= flag;
            }
            else {
                contextFlags &= ~flag;
            }
        }

getNodePos:

() {
            return scanner.🔶getStartPos();
        }

tryScan:

(callback) {
            return 🔶speculationHelper(callback, false);
        }

parseAnyContextualModifier:

() {
            return ts.🔷isModifierKind(🔷token()) && 🔷tryParse(nextTokenCanFollowModifier);
        }
Inlined functions:
token
() {
            return currentToken;
        }
isModifierKind
(token) {
        switch (token) {
            case 116:
            case 119:
            case 75:
            case 123:
            case 78:
            case 83:
            case 113:
            case 111:
            case 112:
            case 130:
            case 114:
                return true;
        }
        return false;
    }
tryParse
(callback) {
            return 🔶speculationHelper(callback, false);
        }

isLiteralPropertyName:

() {
            return ts.🔷tokenIsIdentifierOrKeyword(🔷token()) ||
                🔷token() === 9 ||
                🔷token() === 8;
        }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

lookAhead:

~recompile~
~recompile~
(callback) {
            return 🔶speculationHelper(callback, true);
        }

isIndexSignature:

() {
            if (🔷token() !== 20) {
                return false;
            }
            return 🔷lookAhead(isUnambiguouslyIndexSignature);
        }
Inlined functions:
token
() {
            return currentToken;
        }
lookAhead
(callback) {
            return 🔶speculationHelper(callback, true);
        }

parsePropertyName:

~recompile~
~recompile~
~recompile~
() {
            return 🔷parsePropertyNameWorker(true);
        }
Inlined functions:
parsePropertyNameWorker
(allowComputedPropertyNames) {
            if (🔷token() === 9 || 🔷token() === 8) {
                return 🔷parseLiteralNode(true);
            }
            if (allowComputedPropertyNames && 🔷token() === 20) {
                return 🔷parseComputedPropertyName();
            }
            return 🔶parseIdentifierName();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseLiteralNode
(internName) {
            return 🔶parseLiteralLikeNode(🔷token(), internName);
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseComputedPropertyName
() {
            var node = 🔷createNode(142);
            🔷parseExpected(20);
            node.expression = 🔷allowInAnd(parseExpression);
            🔷parseExpected(21);
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔶lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
allowInAnd
(func) {
            return 🔷doOutsideOfContext(2048, func);
        }
Inlined functions:
doOutsideOfContext
(context, func) {
            var contextFlagsToClear = context & contextFlags;
            if (contextFlagsToClear) {
                🔶setContextFlag(false, contextFlagsToClear);
                var result = 🔶️func();
                🔶setContextFlag(true, contextFlagsToClear);
                return result;
            }
            return 🔶️func();
        }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔶lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }

parseTypeParameters:

() {
            if (🔷token() === 26) {
                return 🔷parseBracketedList(18, parseTypeParameter, 26, 28);
            }
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseBracketedList
(kind, parseElement, open, close) {
            if (🔷parseExpected(open)) {
                var result = 🔶parseDelimitedList(kind, parseElement);
                🔷parseExpected(close);
                return result;
            }
            return 🔶️createMissingList();
        }
Inlined functions:
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts⚠️.Diagnostics⚠️._0_expected, ts.🔶tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔶lastOrUndefined(parseDiagnostics);
            if (!lastError || start ⚠️!== lastError⚠️.start) {
                parseDiagnostics.🔶️push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts⚠️.Diagnostics⚠️._0_expected, ts.🔶tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔶lastOrUndefined(parseDiagnostics);
            if (!lastError || start ⚠️!== lastError⚠️.start) {
                parseDiagnostics.🔶️push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }

pushComment:

~recompile~
~recompile~
~recompile~
~recompile~
(text) {
                        if (!margin) {
                            margin = indent;
                        }
                        comments.push(text);
                        indent += text.length;
                    }

getTokenText:

() { return text.🔶substring(tokenPos, pos); }

isWhiteSpaceSingleLine:

~recompile~
~recompile~
(ch) {
        return ch === 32 ||
            ch === 9 ||
            ch === 11 ||
            ch === 12 ||
            ch === 160 ||
            ch === 133 ||
            ch === 5760 ||
            ch >= 8192 && ch <= 8203 ||
            ch === 8239 ||
            ch === 8287 ||
            ch === 12288 ||
            ch === 65279;
    }

tryParse:

(callback) {
            return 🔶speculationHelper(callback, false);
        }

parsePropertyNameWorker:

(allowComputedPropertyNames) {
            if (🔷token() === 9 || 🔷token() === 8) {
                return 🔶parseLiteralNode(true);
            }
            if (allowComputedPropertyNames && 🔷token() === 20) {
                return 🔶️parseComputedPropertyName();
            }
            return 🔷parseIdentifierName();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseIdentifierName
() {
            return 🔷createIdentifier(ts.🔷tokenIsIdentifierOrKeyword(🔷token()));
        }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
createIdentifier
(isIdentifier, diagnosticMessage) {
            identifierCount++;
            if (isIdentifier) {
                var node = 🔷createNode(70);
                if (🔷token() !== 70) {
                    node.originalKeywordKind = 🔷token();
                }
                node.text = 🔷internIdentifier(scanner.getTokenValue());
                🔷nextToken();
                return 🔷finishNode(node);
            }
            return 🔶️createMissingNode(70, false, diagnosticMessage || ts⚠️.Diagnostics⚠️.Identifier_expected);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
internIdentifier
(text) {
            text = ts.🔷escapeIdentifier(text);
            return identifiers⚠️[text] || (identifiers[text] ⚠️= text);
        }
Inlined functions:
escapeIdentifier
(identifier) {
        return identifier.length >= 2 && identifier.charCodeAt(0) === 95 && identifier.🔶️charCodeAt(1) === 95 ? "_" + identifier : identifier;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }

parseTypeMember:

() {
            if (🔷token() === 18 || 🔷token() === 26) {
                return 🔷parseSignatureMember(153);
            }
            if (🔶token() === 93 && 🔶lookAhead(isStartOfConstructSignature)) {
                return 🔶parseSignatureMember(154);
            }
            var fullStart = 🔶getNodePos();
            var modifiers = 🔶parseModifiers();
            if (🔶isIndexSignature()) {
                return 🔶️parseIndexSignatureDeclaration(fullStart, undefined, modifiers);
            }
            return 🔶parsePropertyOrMethodSignature(fullStart, modifiers);
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseSignatureMember
(kind) {
            var node = 🔷createNode(kind);
            if (kind === 154) {
                🔷parseExpected(93);
            }
            🔶fillSignature(55, false, false, false, node);
            🔷parseTypeMemberSemicolon();
            return 🔶addJSDocComment(🔶finishNode(node));
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts⚠️.Diagnostics⚠️._0_expected, ts.🔶tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔶lastOrUndefined(parseDiagnostics);
            if (!lastError || start ⚠️!== lastError⚠️.start) {
                parseDiagnostics.🔶️push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
parseTypeMemberSemicolon
() {
            if (🔷parseOptional(25)) {
                return;
            }
            🔷parseSemicolon();
        }
Inlined functions:
parseOptional
(t) {
            if (🔷token() === t) {
                🔷nextToken();
                return true;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
parseSemicolon
() {
            if (🔷canParseSemicolon()) {
                if (🔷token() === 24) {
                    🔷nextToken();
                }
                return true;
            }
            else {
                return 🔶parseExpected(24);
            }
        }
Inlined functions:
canParseSemicolon
() {
            if (🔷token() === 24) {
                return true;
            }
            return 🔷token() === 17 || 🔷token() === 1 || scanner.🔶hasPrecedingLineBreak();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }

canParseSemicolon:

() {
            if (🔷token() === 24) {
                return true;
            }
            return 🔷token() === 17 || 🔷token() === 1 || scanner.🔶hasPrecedingLineBreak();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

parseTypeAnnotation:

() {
            return 🔷parseOptional(55) ? 🔷parseType() : undefined;
        }
Inlined functions:
parseOptional
(t) {
            if (🔷token() === t) {
                🔷nextToken();
                return true;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
parseType
() {
            return 🔷doOutsideOfContext(20480, parseTypeWorker);
        }
Inlined functions:
doOutsideOfContext
(context, func) {
            var contextFlagsToClear = context & contextFlags;
            if (contextFlagsToClear) {
                🔶setContextFlag(false, contextFlagsToClear);
                var result = 🔶️func();
                🔶setContextFlag(true, contextFlagsToClear);
                return result;
            }
            return 🔶️func();
        }

parseSemicolon:

() {
            if (🔷canParseSemicolon()) {
                if (🔷token() === 24) {
                    🔷nextToken();
                }
                return true;
            }
            else {
                return 🔶parseExpected(24);
            }
        }
Inlined functions:
canParseSemicolon
() {
            if (🔷token() === 24) {
                return true;
            }
            return 🔷token() === 17 || 🔷token() === 1 || scanner.🔶hasPrecedingLineBreak();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }

getJSDocCommentRanges:

~recompile~
~recompile~
(node, text) {
        var commentRanges = (node⚠️.kind === 144 ||
            node⚠️.kind === 143 ||
            node⚠️.kind === 184 ||
            node⚠️.kind === 185) ?
            ts.🔷concatenate(ts.🔷getTrailingCommentRanges(text, node.pos), ts.🔷getLeadingCommentRanges(text, node.pos)) :
            🔷getLeadingCommentRangesOfNodeFromText(node, text);
        return ts.🔷filter(commentRanges, 🔶️function (comment) {
            return text.charCodeAt(comment.pos + 1) === 42 &&
                text.charCodeAt(comment.pos + 2) === 42 &&
                text.charCodeAt(comment.pos + 3) !== 47;
        });
    }
Inlined functions:
getTrailingCommentRanges
(text, pos) {
        return 🔷reduceEachTrailingCommentRange(text, pos, appendCommentRange, undefined, undefined);
    }
Inlined functions:
reduceEachTrailingCommentRange
(text, pos, cb, state, initial) {
        return iterateCommentRanges(true, text, pos, true, cb, state, initial);
    }
getLeadingCommentRanges
(text, pos) {
        return 🔷reduceEachLeadingCommentRange(text, pos, appendCommentRange, undefined, undefined);
    }
Inlined functions:
reduceEachLeadingCommentRange
(text, pos, cb, state, initial) {
        return iterateCommentRanges(true, text, pos, false, cb, state, initial);
    }
concatenate
(array1, array2) {
        if (!🔷some(array2))
            return array1;
        if (!🔶️some(array1))
            return array2;
        return array1.🔶️concat(array2);
    }
Inlined functions:
some
(array, predicate) {
        if (array) {
            if (predicate) {
                for (var _i = 0, array_5 = array; _i ⚠️< array_5⚠️.length; _i++) {
                    var v = array_5⚠️[_i];
                    if (🔶️predicate(v)) {
                        return true;
                    }
                }
            }
            else {
                return array.length > 0;
            }
        }
        return false;
    }
getLeadingCommentRangesOfNodeFromText
(node, text) {
        return ts.🔷getLeadingCommentRanges(text, node⚠️.pos);
    }
Inlined functions:
getLeadingCommentRanges
(text, pos) {
        return 🔷reduceEachLeadingCommentRange(text, pos, appendCommentRange, undefined, undefined);
    }
Inlined functions:
reduceEachLeadingCommentRange
(text, pos, cb, state, initial) {
        return 🔶iterateCommentRanges(true, text, pos, false, cb, state, initial);
    }
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;
    }

isStartOfType:

() {
            switch (🔷token()) {
                case 118:
                case 134:
                case 132:
                case 121:
                case 135:
                case 104:
                case 137:
                case 94:
                case 98:
                case 102:
                case 129:
                case 16:
                case 20:
                case 26:
                case 48:
                case 47:
                case 93:
                case 9:
                case 8:
                case 100:
                case 85:
                    return true;
                case 37:
                    return 🔶lookAhead(nextTokenIsNumericLiteral);
                case 18:
                    return 🔶lookAhead(isStartOfParenthesizedOrFunctionType);
                default:
                    return 🔷isIdentifier();
            }
        }
Inlined functions:
token
() {
            return currentToken;
        }
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

parseTypeMemberSemicolon:

() {
            if (🔷parseOptional(25)) {
                return;
            }
            🔷parseSemicolon();
        }
Inlined functions:
parseOptional
(t) {
            if (🔷token() === t) {
                🔷nextToken();
                return true;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
parseSemicolon
() {
            if (🔷canParseSemicolon()) {
                if (🔷token() === 24) {
                    🔷nextToken();
                }
                return true;
            }
            else {
                return 🔶parseExpected(24);
            }
        }
Inlined functions:
canParseSemicolon
() {
            if (🔷token() === 24) {
                return true;
            }
            return 🔷token() === 17 || 🔷token() === 1 || scanner.🔶hasPrecedingLineBreak();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }

nextJSDocToken:

~recompile~
~recompile~
() {
                    return currentToken = scanner.🔶scanJSDocToken();
                }

parseTokenNode:

~recompile~
~recompile~
~recompile~
() {
            var node = 🔷createNode(🔷token());
            🔷nextToken();
            return 🔷finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }

scanJSDocToken:

() {
            if (pos >= end) {
                return token = 1;
            }
            startPos = pos;
            tokenPos = pos;
            var ch = text.charCodeAt(pos);
            switch (ch) {
                case 9:
                case 11:
                case 12:
                case 32:
                    while (pos < end && 🔷isWhiteSpaceSingleLine(text.charCodeAt(pos))) {
                        pos++;
                    }
                    return token = 5;
                case 64:
                    pos++;
                    return token = 56;
                case 10:
                case 13:
                    pos++;
                    return token = 4;
                case 42:
                    pos++;
                    return token = 38;
                case 123:
                    pos++;
                    return token = 16;
                case 125:
                    pos++;
                    return token = 17;
                case 91:
                    pos++;
                    return token = 20;
                case 93:
                    pos++;
                    return token = 21;
                case 61:
                    pos++;
                    return token = 57;
                case 44:
                    pos++;
                    return token = 25;
                case 46:
                    pos++;
                    return token = 22;
            }
            if (🔷isIdentifierStart(ch, 5)) {
                pos++;
                while (🔷isIdentifierPart(text.charCodeAt(pos), 5) && pos < end) {
                    pos++;
                }
                return token = 70;
            }
            else {
                return pos += 1, token = 0;
            }
        }
Inlined functions:
isWhiteSpaceSingleLine
(ch) {
        return ch === 32 ||
            ch === 9 ||
            ch === 11 ||
            ch === 12 ||
            ch === 160 ||
            ch === 133 ||
            ch === 5760 ||
            ch >= 8192 && ch <= 8203 ||
            ch === 8239 ||
            ch === 8287 ||
            ch === 12288 ||
            ch === 65279;
    }
isIdentifierStart
(ch, languageVersion) {
        return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 ||
            ch === 36 || ch === 95 ||
            ch > 127 && 🔷isUnicodeIdentifierStart(ch, languageVersion);
    }
Inlined functions:
isUnicodeIdentifierStart
(code, languageVersion) {
        return languageVersion >= 1 ?
            🔷lookupInUnicodeMap(code, unicodeES5IdentifierStart) :
            🔶️lookupInUnicodeMap(code, unicodeES3IdentifierStart);
    }
Inlined functions:
lookupInUnicodeMap
(code, map) {
        if (code < map[0]) {
            return false;
        }
        var lo = 0;
        var hi = map.length;
        var mid;
        while (lo + 1 < hi) {
            mid = lo + (hi - lo) / 2;
            mid -= mid % 2;
            if (map[mid] <= code && code <= map[mid + 1]) {
                return true;
            }
            if (code < map[mid]) {
                hi = mid;
            }
            else {
                lo = mid + 2;
            }
        }
        return false;
    }
isIdentifierPart
(ch, languageVersion) {
        return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 ||
            ch >= 48 && ch <= 57 || ch === 36 || ch === 95 ||
            ch > 127 && 🔷isUnicodeIdentifierPart(ch, languageVersion);
    }
Inlined functions:
isUnicodeIdentifierPart
(code, languageVersion) {
        return languageVersion >= 1 ?
            🔷lookupInUnicodeMap(code, unicodeES5IdentifierPart) :
            🔶️lookupInUnicodeMap(code, unicodeES3IdentifierPart);
    }
Inlined functions:
lookupInUnicodeMap
(code, map) {
        if (code < map[0]) {
            return false;
        }
        var lo = 0;
        var hi = map.length;
        var mid;
        while (lo + 1 < hi) {
            mid = lo + (hi - lo) / 2;
            mid -= mid % 2;
            if (map[mid] <= code && code <= map[mid + 1]) {
                return true;
            }
            if (code < map[mid]) {
                hi = mid;
            }
            else {
                lo = mid + 2;
            }
        }
        return false;
    }

isLeftHandSideExpression:

(node) {
        return 🔶isLeftHandSideExpressionKind(ts.🔷skipPartiallyEmittedExpressions(node)⚠️.kind);
    }
Inlined functions:
skipPartiallyEmittedExpressions
(node) {
        while (node⚠️.kind === 294) {
            node = node⚠️.expression;
        }
        return node;
    }

setText:

(newText, start, length) {
            text = newText || "";
            end = length === undefined ? text.length : start + length;
            🔶setTextPos(start || 0);
        }

setTextPos:

(textPos) {
            ts.Debug.🔶️assert(textPos >= 0);
            pos = textPos;
            startPos = textPos;
            tokenPos = textPos;
            token = 0;
            precedingLineBreak = false;
            tokenValue = undefined;
            hasExtendedUnicodeEscape = false;
            tokenIsUnterminated = false;
        }

parseJSDocComment:

(parent, start, length) {
                var saveToken = currentToken;
                var saveParseDiagnosticsLength = parseDiagnostics.length;
                var saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
                var comment = parseJSDocCommentWorker(start, length);
                if (comment) {
                    comment.parent = parent;
                }
                currentToken = saveToken;
                parseDiagnostics.length ⚠️= saveParseDiagnosticsLength;
                parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode;
                return comment;
            }

parsePropertyOrMethodSignature:

(fullStart, modifiers) {
            var name = 🔷parsePropertyName();
            var questionToken = 🔷parseOptionalToken(54);
            if (🔶token() === 18 || 🔶token() === 26) {
                var method = createNode(148, fullStart);
                method.modifiers = modifiers;
                method.name = name;
                method.questionToken = questionToken;
                🔶fillSignature(55, false, false, false, method);
                🔶parseTypeMemberSemicolon();
                return 🔶addJSDocComment(🔶finishNode(method));
            }
            else {
                var property = createNode(146, fullStart);
                property.modifiers = modifiers;
                property.name = name;
                property.questionToken = questionToken;
                property.type = 🔶parseTypeAnnotation();
                if (🔶token() === 57) {
                    property.initializer ⚠️= parseNonParameterInitializer();
                }
                🔶parseTypeMemberSemicolon();
                return 🔶addJSDocComment(🔶finishNode(property));
            }
        }
Inlined functions:
parsePropertyName
() {
            return 🔷parsePropertyNameWorker(true);
        }
Inlined functions:
parsePropertyNameWorker
(allowComputedPropertyNames) {
            if (🔷token() === 9 || 🔷token() === 8) {
                return 🔶parseLiteralNode(true);
            }
            if (allowComputedPropertyNames && 🔷token() === 20) {
                return 🔶️parseComputedPropertyName();
            }
            return 🔷parseIdentifierName();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseIdentifierName
() {
            return 🔷createIdentifier(ts.🔷tokenIsIdentifierOrKeyword(🔷token()));
        }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
createIdentifier
(isIdentifier, diagnosticMessage) {
            identifierCount++;
            if (isIdentifier) {
                var node = 🔷createNode(70);
                if (🔷token() !== 70) {
                    node.originalKeywordKind = 🔷token();
                }
                node.text = 🔷internIdentifier(scanner.🔶getTokenValue());
                🔷nextToken();
                return 🔷finishNode(node);
            }
            return 🔶️createMissingNode(70, false, diagnosticMessage || ts⚠️.Diagnostics⚠️.Identifier_expected);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔶️new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔶️new IdentifierConstructor(kind, pos, pos) :
                    🔶️new TokenConstructor(kind, pos, pos);
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
internIdentifier
(text) {
            text = ts.🔶escapeIdentifier(text);
            return identifiers⚠️[text] || (identifiers[text] ⚠️= text);
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }
parseOptionalToken
(t) {
            if (🔷token() === t) {
                return 🔷parseTokenNode();
            }
            return undefined;
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔶nextToken();
            return 🔶finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

parseKeywordAndNoDot:

() {
            var node = 🔷parseTokenNode();
            return 🔷token() === 22 ? undefined : node;
        }
Inlined functions:
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔷nextToken();
            return 🔷finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }
token
() {
            return currentToken;
        }

inContext:

(flags) {
            return (contextFlags & flags) !== 0;
        }

parseLeftHandSideExpressionOrHigher:

() {
            var expression = 🔷token() === 96
                ? 🔶️parseSuperExpression()
                : 🔷parseMemberExpressionOrHigher();
            return 🔶️parseCallExpressionRest(expression);
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseMemberExpressionOrHigher
() {
            var expression = 🔶parsePrimaryExpression();
            return 🔶parseMemberExpressionRest(expression);
        }

parseRightSideOfDot:

~recompile~
~recompile~
(allowIdentifierNames) {
            if (scanner.🔶hasPrecedingLineBreak() && ts.🔶tokenIsIdentifierOrKeyword(🔶token())) {
                var matchesPattern = 🔶lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
                if (matchesPattern) {
                    return 🔶️createMissingNode(70, true, ts⚠️.Diagnostics⚠️.Identifier_expected);
                }
            }
            return allowIdentifierNames ? 🔷parseIdentifierName() : 🔶parseIdentifier();
        }
Inlined functions:
parseIdentifierName
() {
            return 🔷createIdentifier(ts.🔷tokenIsIdentifierOrKeyword(🔷token()));
        }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
createIdentifier
(isIdentifier, diagnosticMessage) {
            identifierCount++;
            if (isIdentifier) {
                var node = 🔷createNode(70);
                if (🔷token() !== 70) {
                    node.originalKeywordKind = 🔷token();
                }
                node.text = 🔷internIdentifier(scanner.getTokenValue());
                🔷nextToken();
                return 🔷finishNode(node);
            }
            return 🔷createMissingNode(70, false, diagnosticMessage || ts⚠️.Diagnostics⚠️.Identifier_expected);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
internIdentifier
(text) {
            text = ts.🔷escapeIdentifier(text);
            return identifiers⚠️[text] || (identifiers[text] ⚠️= text);
        }
Inlined functions:
escapeIdentifier
(identifier) {
        return identifier⚠️.length >= 2 && identifier.charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 ? "_" + identifier : identifier;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }
createMissingNode
(kind, reportAtCurrentPosition, diagnosticMessage, arg0) {
            if (reportAtCurrentPosition) {
                🔶️parseErrorAtPosition(scanner.🔶getStartPos(), 0, diagnosticMessage, arg0);
            }
            else {
                🔷parseErrorAtCurrentToken(diagnosticMessage, arg0);
            }
            var result = 🔷createNode(kind, scanner.🔶getStartPos());
            result.text = "";
            return 🔶finishNode(result);
        }
Inlined functions:
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔶lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔶️new IdentifierConstructor(kind, pos, pos) :
                    🔶️new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

⛔ reScanGreaterToken (deoptimizated):

~recompile~
- Deopt: <JS Function isListElement (SharedFunctionInfo 0x98bdb9c8f39)> (opt #68) @61, FP to SP delta: 120, caller sp: 0x7fff5fbfd248
~recompile~
() {
            if (token === 28) {
                if (text.charCodeAt(pos) === 62) {
                    if (text.🔶️charCodeAt(pos ⚠️+ 1) ⚠️=== 62) {
                        if (text.⚠️charCodeAt(pos ⚠️+ 2) ⚠️=== 61) {
                            return pos +⚠️= 3, token = 66;
                        }
                        return pos +⚠️= 2, token = 46;
                    }
                    if (text.⚠️charCodeAt(pos ⚠️+ 1) ⚠️=== 61) {
                        return pos +⚠️= 2, token = 65;
                    }
                    pos++;
                    return token = 45;
                }
                if (text.charCodeAt(pos) === 61) {
                    pos++;
                    return token = 30;
                }
            }
            return token;
        }
- Deopt: <JS Function isListTerminator (SharedFunctionInfo 0x98bdb9c93b9)> (opt #95) @13, FP to SP delta: 56, caller sp: 0x7fff5fbfd1d8

parseInitializer:

(inParameter) {
            if (🔷token() !== 57) {
                if (scanner.🔶hasPrecedingLineBreak() || (inParameter && 🔷token() === 16) || !🔶isStartOfExpression()) {
                    return undefined;
                }
            }
            🔷parseExpected(57);
            return 🔶parseAssignmentExpressionOrHigher();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts⚠️.Diagnostics⚠️._0_expected, ts.🔶tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔶lastOrUndefined(parseDiagnostics);
            if (!lastError || start ⚠️!== lastError⚠️.start) {
                parseDiagnostics.🔶️push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }

parseBinaryExpressionOrHigher:

(precedence) {
            var leftOperand = 🔶parseUnaryExpressionOrHigher();
            return 🔶parseBinaryExpressionRest(precedence, leftOperand);
        }

parseIdentifierName:

~recompile~
~recompile~
() {
            return 🔷createIdentifier(ts.🔷tokenIsIdentifierOrKeyword(🔷token()));
        }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
createIdentifier
(isIdentifier, diagnosticMessage) {
            identifierCount++;
            if (isIdentifier) {
                var node = 🔷createNode(70);
                if (🔷token() !== 70) {
                    node.originalKeywordKind = 🔷token();
                }
                node.text = 🔷internIdentifier(scanner.getTokenValue());
                🔷nextToken();
                return 🔷finishNode(node);
            }
            return 🔷createMissingNode(70, false, diagnosticMessage || ts⚠️.Diagnostics⚠️.Identifier_expected);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
internIdentifier
(text) {
            text = ts.🔷escapeIdentifier(text);
            return identifiers⚠️[text] || (identifiers[text] ⚠️= text);
        }
Inlined functions:
escapeIdentifier
(identifier) {
        return identifier⚠️.length >= 2 && identifier.🔶️charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 ? "_" + identifier : identifier;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }
createMissingNode
(kind, reportAtCurrentPosition, diagnosticMessage, arg0) {
            if (reportAtCurrentPosition) {
                🔶️parseErrorAtPosition(scanner.🔶getStartPos(), 0, diagnosticMessage, arg0);
            }
            else {
                🔷parseErrorAtCurrentToken(diagnosticMessage, arg0);
            }
            var result = 🔷createNode(kind, scanner.🔶getStartPos());
            result.text = "";
            return 🔶finishNode(result);
        }
Inlined functions:
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔶️new IdentifierConstructor(kind, pos, pos) :
                    🔶️new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

isYieldExpression:

() {
            if (🔷token() === 115) {
                if (🔶inYieldContext()) {
                    return true;
                }
                return 🔶lookAhead(nextTokenIsIdentifierOrKeywordOrNumberOnSameLine);
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }

isParenthesizedArrowFunctionExpression:

() {
            if (🔷token() === 18 || 🔷token() === 26 || 🔷token() === 119) {
                return 🔷lookAhead(isParenthesizedArrowFunctionExpressionWorker);
            }
            if (🔷token() === 35) {
                return 1;
            }
            return 0;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
lookAhead
(callback) {
            return 🔶speculationHelper(callback, true);
        }
token
() {
            return currentToken;
        }

tryParseAsyncSimpleArrowFunctionExpression:

() {
            if (🔷token() === 119) {
                var isUnParenthesizedAsyncArrowFunction = 🔶lookAhead(isUnParenthesizedAsyncArrowFunctionWorker);
                if (isUnParenthesizedAsyncArrowFunction ⚠️=== 1) {
                    var asyncModifier = 🔶️parseModifiersForArrowFunction();
                    var expr = 🔶parseBinaryExpressionOrHigher(0);
                    return 🔶️parseSimpleArrowFunctionExpression(expr, asyncModifier);
                }
            }
            return undefined;
        }
Inlined functions:
token
() {
            return currentToken;
        }

isBinaryOperator:

() {
            if (🔷inDisallowInContext() && 🔶token() ⚠️=== 91) {
                return false;
            }
            return 🔶getBinaryOperatorPrecedence() > 0;
        }
Inlined functions:
inDisallowInContext
() {
            return 🔷inContext(2048);
        }
Inlined functions:
inContext
(flags) {
            return (contextFlags & flags) !== 0;
        }

isAssignmentOperator:

(token) {
        return token >= 57 && token <= 69;
    }

parseIdentifierOrPattern:

~recompile~
~recompile~
() {
            if (🔷token() === 20) {
                return 🔷parseArrayBindingPattern();
            }
            if (🔶token() === 16) {
                return 🔶️parseObjectBindingPattern();
            }
            return 🔶parseIdentifier();
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseArrayBindingPattern
() {
            var node = 🔷createNode(173);
            🔷parseExpected(20);
            node.elements = 🔶parseDelimitedList(10, parseArrayBindingElement);
            🔷parseExpected(21);
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

isLeftHandSideExpressionKind:

(kind) {
        return kind === 177
            || kind === 178
            || kind === 180
            || kind === 179
            || kind === 246
            || kind === 247
            || kind === 181
            || kind === 175
            || kind === 183
            || kind === 176
            || kind === 197
            || kind === 184
            || kind === 70
            || kind === 11
            || kind === 8
            || kind === 9
            || kind === 12
            || kind === 194
            || kind === 85
            || kind === 94
            || kind === 98
            || kind === 100
            || kind === 96
            || kind === 201
            || kind === 297;
    }

doOutsideOfContext:

(context, func) {
            var contextFlagsToClear = context & contextFlags;
            if (contextFlagsToClear) {
                🔶setContextFlag(false, contextFlagsToClear);
                var result = 🔶️func();
                🔶setContextFlag(true, contextFlagsToClear);
                return result;
            }
            return 🔶️func();
        }

getBinaryOperatorPrecedence:

() {
            switch (🔷token()) {
                case 53:
                    return 1;
                case 52:
                    return 2;
                case 48:
                    return 3;
                case 49:
                    return 4;
                case 47:
                    return 5;
                case 31:
                case 32:
                case 33:
                case 34:
                    return 6;
                case 26:
                case 28:
                case 29:
                case 30:
                case 92:
                case 91:
                case 117:
                    return 7;
                case 44:
                case 45:
                case 46:
                    return 8;
                case 36:
                case 37:
                    return 9;
                case 38:
                case 40:
                case 41:
                    return 10;
                case 39:
                    return 11;
            }
            return -1;
        }
Inlined functions:
token
() {
            return currentToken;
        }

tryFile:

(fileName, failedLookupLocations, onlyRecordFailures, state) {
        if (!onlyRecordFailures && state.host.🔶fileExists(fileName)) {
            if (state.traceEnabled) {
                🔶️trace(state⚠️.host, ts⚠️.Diagnostics⚠️.File_0_exist_use_it_as_a_name_resolution_result, fileName);
            }
            return fileName;
        }
        else {
            if (state.traceEnabled) {
                🔶️trace(state⚠️.host, ts⚠️.Diagnostics⚠️.File_0_does_not_exist, fileName);
            }
            failedLookupLocations.push(fileName);
            return undefined;
        }
    }

⛔ (deoptimizated):

~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
- Deopt: <JS Function instantiateTypeNoAlias (SharedFunctionInfo 0x3f6f7cfb6939)> (opt #769) @19, FP to SP delta: 264, caller sp: 0x7fff5fbfcaa0
- Deopt: <JS Function instantiateTypeNoAlias (SharedFunctionInfo 0x3f6f7cfb6939)> (opt #769) @11, FP to SP delta: 264, caller sp: 0x7fff5fbfcd58
- Deopt: <JS Function getTypeOfVariableOrParameterOrProperty (SharedFunctionInfo 0x3f6f7cfacb99)> (opt #754) @126, FP to SP delta: 184, caller sp: 0x7fff5fbfc8c0
~recompile~
- Deopt: <JS Function getTypeOfVariableOrParameterOrProperty (SharedFunctionInfo 0x3f6f7cfacb99)> (opt #822) @18, FP to SP delta: 184, caller sp: 0x7fff5fbfceb8
~recompile~
~recompile~
~recompile~
- Deopt: <JS Function computeParameter (SharedFunctionInfo 0x98bdb9d8909)> (opt #665) @21, FP to SP delta: 48, caller sp: 0x7fff5fbfd288
- Deopt: <JS Function isThisIdentifier (SharedFunctionInfo 0x30d407fe5da1)> (opt #1075) @3, FP to SP delta: 24, caller sp: 0x7fff5fbfd220
- Deopt: <JS Function hasModifier (SharedFunctionInfo 0x30d407fe66a1)> (opt #370) @7, FP to SP delta: 48, caller sp: 0x7fff5fbfd950
- Deopt: <JS Function computePropertyAccess (SharedFunctionInfo 0x98bdb9d9389)> (opt #660) @2, FP to SP delta: 24, caller sp: 0x7fff5fbfd020
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
- Deopt: <JS Function visitorWorker (SharedFunctionInfo 0x173c75a94911)> (opt #1246) @6, FP to SP delta: 24, caller sp: 0x7fff5fbfddd8
- Deopt: <JS Function visitTypeScript (SharedFunctionInfo 0x173c75a94f11)> (opt #1336) @86, FP to SP delta: 176, caller sp: 0x7fff5fbfdda0
- Deopt: <JS Function isStaticInitializedProperty (SharedFunctionInfo 0x173c75a95be9)> (opt #1342) @1, FP to SP delta: 64, caller sp: 0x7fff5fbfdc78
- Deopt: <JS Function visitor (SharedFunctionInfo 0x173c75a94851)> (opt #1464) @1, FP to SP delta: 136, caller sp: 0x7fff5fbfd8e0
- Deopt: <JS Function classElementVisitor (SharedFunctionInfo 0x173c75a94cd1)> (opt #1301) @1, FP to SP delta: 136, caller sp: 0x7fff5fbfdb08
- Deopt: <JS Function classElementVisitorWorker (SharedFunctionInfo 0x173c75a94d91)> (opt #1343) @3, FP to SP delta: 32, caller sp: 0x7fff5fbfda78
- Deopt: <JS Function addClassElementDecorationStatements (SharedFunctionInfo 0x173c75a968a9)> (opt #1456) @3, FP to SP delta: 96, caller sp: 0x7fff5fbfdcf8
- Deopt: <JS Function visitor (SharedFunctionInfo 0x173c75a9ddf1)> (opt #1349) @1, FP to SP delta: 24, caller sp: 0x7fff5fbfde68
- Deopt: <JS Function saveStateAndInvoke (SharedFunctionInfo 0x173c75aa3901)> (opt #1266) @4, FP to SP delta: 112, caller sp: 0x7fff5fbfe0b0
- Deopt: <JS Function visitor (SharedFunctionInfo 0x173c75aa3781)> (opt #1261) @1, FP to SP delta: 24, caller sp: 0x7fff5fbfdec0
- Deopt: <JS Function dispatcher (SharedFunctionInfo 0x173c75aa3841)> (opt #1286) @2, FP to SP delta: 104, caller sp: 0x7fff5fbfddf0
- Deopt: <JS Function visitorWorker (SharedFunctionInfo 0x173c75aa3cc1)> (opt #1272) @1, FP to SP delta: 64, caller sp: 0x7fff5fbfddb8
- Deopt: <JS Function visitJavaScript (SharedFunctionInfo 0x173c75aa3f01)> (opt #1357) @133, FP to SP delta: 288, caller sp: 0x7fff5fbfdd80
- Deopt: <JS Function getClassExtendsHeritageClauseElement (SharedFunctionInfo 0x30d407fe2f21)> (opt #1865) @6, FP to SP delta: 32, caller sp: 0x7fff5fbfdc68
- Deopt: <JS Function transformFunctionBody (SharedFunctionInfo 0x173c75aa5a39)> (opt #1462) @2, FP to SP delta: 368, caller sp: 0x7fff5fbfd998
- Deopt: <JS Function getReferencedImportDeclaration (SharedFunctionInfo 0x3f6f7cfcd8c9)> (opt #1515) @14, FP to SP delta: 152, caller sp: 0x7fff5fbfdf98
- Deopt: <JS Function getReferencedValueDeclaration (SharedFunctionInfo 0x3f6f7cfce889)> (opt #1596) @20, FP to SP delta: 128, caller sp: 0x7fff5fbfdf98
- Deopt: <JS Function sourceElementVisitor (SharedFunctionInfo 0x173c75ab3ad1)> (opt #1403) @31, FP to SP delta: 96, caller sp: 0x7fff5fbfdf48
~recompile~
~recompile~
~recompile~
~recompile~
(i) { return array[i]; }

parseBindingElementInitializer:

(inParameter) {
            return inParameter ? 🔷parseParameterInitializer() : 🔷parseNonParameterInitializer();
        }
Inlined functions:
parseParameterInitializer
() {
            return 🔷parseInitializer(true);
        }
Inlined functions:
parseInitializer
(inParameter) {
            if (🔷token() !== 57) {
                if (scanner.🔶hasPrecedingLineBreak() || (inParameter && 🔷token() === 16) || !🔶isStartOfExpression()) {
                    return undefined;
                }
            }
            🔷parseExpected(57);
            return 🔶parseAssignmentExpressionOrHigher();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔶lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
parseNonParameterInitializer
() {
            return 🔷parseInitializer(false);
        }
Inlined functions:
parseInitializer
(inParameter) {
            if (🔷token() !== 57) {
                if (scanner.🔶hasPrecedingLineBreak() || (inParameter && 🔷token() === 16) || !🔶isStartOfExpression()) {
                    return undefined;
                }
            }
            🔷parseExpected(57);
            return 🔶parseAssignmentExpressionOrHigher();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔶lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }

getFullWidth:

~recompile~
~recompile~
(node) {
        return node.end - node.pos;
    }

parseParameterType:

() {
            if (🔷parseOptional(55)) {
                return 🔷parseType();
            }
            return undefined;
        }
Inlined functions:
parseOptional
(t) {
            if (🔷token() === t) {
                🔷nextToken();
                return true;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
parseType
() {
            return 🔷doOutsideOfContext(20480, parseTypeWorker);
        }
Inlined functions:
doOutsideOfContext
(context, func) {
            var contextFlagsToClear = context & contextFlags;
            if (contextFlagsToClear) {
                🔶setContextFlag(false, contextFlagsToClear);
                var result = 🔶️func();
                🔶setContextFlag(true, contextFlagsToClear);
                return result;
            }
            return 🔶️func();
        }

⛔ parseMemberExpressionOrHigher (deoptimizated):

() {
            var expression = 🔶parsePrimaryExpression();
            return 🔶parseMemberExpressionRest(expression);
        }
- Deopt: <JS Function createIdentifier (SharedFunctionInfo 0x98bdb9c83f9)> (opt #141) @47, FP to SP delta: 88, caller sp: 0x7fff5fbfcdb8
- Deopt: <JS Function parseExpected (SharedFunctionInfo 0x98bdb9c7af9)> (opt #62) @20, FP to SP delta: 144, caller sp: 0x7fff5fbfd0a8
- Deopt: <JS Function getFullWidth (SharedFunctionInfo 0x30d407fdce61)> (opt #151) @2, FP to SP delta: 24, caller sp: 0x7fff5fbfd058

inAwaitContext:

() {
            return 🔷inContext(16384);
        }
Inlined functions:
inContext
(flags) {
            return (contextFlags & flags) !== 0;
        }

parseContextualModifier:

(t) {
            return 🔷token() === t && 🔶tryParse(nextTokenCanFollowModifier);
        }
Inlined functions:
token
() {
            return currentToken;
        }

parseIncrementExpression:

~recompile~
~recompile~
~recompile~
~recompile~
() {
            if (🔷token() === 42 || 🔷token() === 43) {
                var node = 🔶createNode(190);
                node.operator ⚠️= token();
                🔶nextToken();
                node.operand ⚠️= parseLeftHandSideExpressionOrHigher();
                return 🔶finishNode(node);
            }
            else if (sourceFile.languageVariant === 1 && 🔷token() === 26 && 🔷lookAhead(nextTokenIsIdentifierOrKeyword)) {
                return 🔶️parseJsxElementOrSelfClosingElement(true);
            }
            var expression = 🔷parseLeftHandSideExpressionOrHigher();
            ts.Debug.🔶️assert(ts.🔷isLeftHandSideExpression(expression));
            if ((🔶token() === 42 || 🔶token() === 43) && !scanner.🔶hasPrecedingLineBreak()) {
                var node = createNode(191, expression.pos);
                node.operand = expression;
                node.operator = 🔶token();
                🔶nextToken();
                return 🔶finishNode(node);
            }
            return expression;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
lookAhead
(callback) {
            return 🔶speculationHelper(callback, true);
        }
parseLeftHandSideExpressionOrHigher
() {
            var expression = 🔷token() === 96
                ? 🔷parseSuperExpression()
                : 🔷parseMemberExpressionOrHigher();
            return parseCallExpressionRest(expression);
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseSuperExpression
() {
            var expression = 🔷parseTokenNode();
            if (🔷token() === 18 || 🔷token() === 22 || 🔶token() ⚠️=== 20) {
                return expression;
            }
            var node = 🔶createNode(177, expression⚠️.pos);
            node.expression ⚠️= expression;
            🔶parseExpectedToken(22, false, ts⚠️.Diagnostics⚠️.super_must_be_followed_by_an_argument_list_or_member_access);
            node.name ⚠️= parseRightSideOfDot(true);
            return 🔶finishNode(node);
        }
Inlined functions:
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔷nextToken();
            return 🔷finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseMemberExpressionOrHigher
() {
            var expression = 🔶parsePrimaryExpression();
            return 🔶parseMemberExpressionRest(expression);
        }
isLeftHandSideExpression
(node) {
        return 🔶isLeftHandSideExpressionKind(ts.🔷skipPartiallyEmittedExpressions(node)⚠️.kind);
    }
Inlined functions:
skipPartiallyEmittedExpressions
(node) {
        while (node⚠️.kind === 294) {
            node = node⚠️.expression;
        }
        return node;
    }

parseUnaryExpressionOrHigher:

() {
            if (🔷isUpdateExpression()) {
                var incrementExpression = 🔶parseIncrementExpression();
                return 🔷token() === 39 ?
                    🔶parseBinaryExpressionRest(🔶getBinaryOperatorPrecedence(), incrementExpression) :
                    incrementExpression;
            }
            var unaryOperator = 🔷token();
            var simpleUnaryExpression = 🔶parseSimpleUnaryExpression();
            if (🔷token() === 39) {
                var start = ts.⚠️skipTrivia(sourceText, simpleUnaryExpression⚠️.pos);
                if (simpleUnaryExpression⚠️.kind ⚠️=== 182) {
                    🔶️parseErrorAtPosition(start, simpleUnaryExpression⚠️.end ⚠️- start, ts⚠️.Diagnostics⚠️.A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses);
                }
                else {
                    🔶️parseErrorAtPosition(start, simpleUnaryExpression⚠️.end ⚠️- start, ts⚠️.Diagnostics⚠️.An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses, ts.⚠️tokenToString(unaryOperator));
                }
            }
            return simpleUnaryExpression;
        }
Inlined functions:
isUpdateExpression
() {
            switch (🔷token()) {
                case 36:
                case 37:
                case 51:
                case 50:
                case 79:
                case 102:
                case 104:
                case 120:
                    return false;
                case 26:
                    if (sourceFile.languageVariant !== 1) {
                        return false;
                    }
                default:
                    return true;
            }
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

isStartOfLeftHandSideExpression:

() {
            switch (🔷token()) {
                case 98:
                case 96:
                case 94:
                case 100:
                case 85:
                case 8:
                case 9:
                case 12:
                case 13:
                case 18:
                case 20:
                case 16:
                case 88:
                case 74:
                case 93:
                case 40:
                case 62:
                case 70:
                    return true;
                default:
                    return 🔷isIdentifier();
            }
        }
Inlined functions:
token
() {
            return currentToken;
        }
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

fillSignature:

~recompile~
~recompile~
(returnToken, yieldContext, awaitContext, requireCompleteParameterList, signature) {
            var returnTokenRequired = returnToken === 35;
            signature.typeParameters ⚠️= parseTypeParameters();
            signature.parameters ⚠️= parseParameterList(yieldContext, awaitContext, requireCompleteParameterList);
            if (returnTokenRequired) {
                🔷parseExpected(returnToken);
                signature.type = 🔶parseTypeOrTypePredicate();
            }
            else if (🔶parseOptional(returnToken)) {
                signature.type ⚠️= parseTypeOrTypePredicate();
            }
        }
Inlined functions:
parseTypeParameters
() {
            if (🔷token() === 26) {
                return 🔷parseBracketedList(18, parseTypeParameter, 26, 28);
            }
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseBracketedList
(kind, parseElement, open, close) {
            if (🔷parseExpected(open)) {
                var result = 🔶parseDelimitedList(kind, parseElement);
                🔷parseExpected(close);
                return result;
            }
            return 🔶️createMissingList();
        }
Inlined functions:
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔶lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔶lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

parseParameterList:

(yieldContext, awaitContext, requireCompleteParameterList) {
            if (🔷parseExpected(18)) {
                var savedYieldContext = 🔷inYieldContext();
                var savedAwaitContext = 🔷inAwaitContext();
                🔷setYieldContext(yieldContext);
                🔷setAwaitContext(awaitContext);
                var result = 🔶parseDelimitedList(16, parseParameter);
                🔷setYieldContext(savedYieldContext);
                🔷setAwaitContext(savedAwaitContext);
                if (!🔷parseExpected(19) && requireCompleteParameterList) {
                    return undefined;
                }
                return result;
            }
            return requireCompleteParameterList ? undefined : 🔶️createMissingList();
        }
Inlined functions:
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
inYieldContext
() {
            return 🔷inContext(4096);
        }
Inlined functions:
inContext
(flags) {
            return (contextFlags & flags) !== 0;
        }
inAwaitContext
() {
            return 🔷inContext(16384);
        }
Inlined functions:
inContext
(flags) {
            return (contextFlags & flags) !== 0;
        }
setYieldContext
(val) {
            🔷setContextFlag(val, 4096);
        }
Inlined functions:
setContextFlag
(val, flag) {
            if (val) {
                contextFlags |= flag;
            }
            else {
                contextFlags &= ~flag;
            }
        }
setAwaitContext
(val) {
            🔷setContextFlag(val, 16384);
        }
Inlined functions:
setContextFlag
(val, flag) {
            if (val) {
                contextFlags |= flag;
            }
            else {
                contextFlags &= ~flag;
            }
        }
setYieldContext
(val) {
            🔷setContextFlag(val, 4096);
        }
Inlined functions:
setContextFlag
(val, flag) {
            if (val) {
                contextFlags |= flag;
            }
            else {
                contextFlags &= ~flag;
            }
        }
setAwaitContext
(val) {
            🔷setContextFlag(val, 16384);
        }
Inlined functions:
setContextFlag
(val, flag) {
            if (val) {
                contextFlags |= flag;
            }
            else {
                contextFlags &= ~flag;
            }
        }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

parseAssignmentExpressionOrHigher:

() {
            if (🔷isYieldExpression()) {
                return 🔶️parseYieldExpression();
            }
            var arrowExpression = 🔶tryParseParenthesizedArrowFunctionExpression() || 🔷tryParseAsyncSimpleArrowFunctionExpression();
            if (arrowExpression) {
                return arrowExpression;
            }
            var expr = 🔷parseBinaryExpressionOrHigher(0);
            if (expr⚠️.kind === 70 && 🔷token() === 35) {
                return 🔶️parseSimpleArrowFunctionExpression(expr);
            }
            if (ts.🔷isLeftHandSideExpression(expr) && ts.🔷isAssignmentOperator(🔷reScanGreaterToken())) {
                return 🔷makeBinaryExpression(expr, 🔷parseTokenNode(), 🔶parseAssignmentExpressionOrHigher());
            }
            return 🔶parseConditionalExpressionRest(expr);
        }
Inlined functions:
isYieldExpression
() {
            if (🔷token() === 115) {
                if (🔶inYieldContext()) {
                    return true;
                }
                return 🔶lookAhead(nextTokenIsIdentifierOrKeywordOrNumberOnSameLine);
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
tryParseAsyncSimpleArrowFunctionExpression
() {
            if (🔷token() === 119) {
                var isUnParenthesizedAsyncArrowFunction = 🔶lookAhead(isUnParenthesizedAsyncArrowFunctionWorker);
                if (isUnParenthesizedAsyncArrowFunction ⚠️=== 1) {
                    var asyncModifier = 🔶️parseModifiersForArrowFunction();
                    var expr = 🔶parseBinaryExpressionOrHigher(0);
                    return 🔶️parseSimpleArrowFunctionExpression(expr, asyncModifier);
                }
            }
            return undefined;
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseBinaryExpressionOrHigher
(precedence) {
            var leftOperand = 🔶parseUnaryExpressionOrHigher();
            return parseBinaryExpressionRest(precedence, leftOperand);
        }
token
() {
            return currentToken;
        }
isLeftHandSideExpression
(node) {
        return 🔶isLeftHandSideExpressionKind(ts.🔷skipPartiallyEmittedExpressions(node)⚠️.kind);
    }
Inlined functions:
skipPartiallyEmittedExpressions
(node) {
        while (node⚠️.kind === 294) {
            node = node⚠️.expression;
        }
        return node;
    }
reScanGreaterToken
() {
            return currentToken = scanner.🔶reScanGreaterToken();
        }
isAssignmentOperator
(token) {
        return token >= 57 && token <= 69;
    }
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔷nextToken();
            return 🔷finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags |= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }
makeBinaryExpression
(left, operatorToken, right) {
            var node = 🔷createNode(192, left⚠️.pos);
            node.left = left;
            node.operatorToken = operatorToken;
            node.right = right;
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔶️new IdentifierConstructor(kind, pos, pos) :
                    🔶️new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

tryParseParenthesizedArrowFunctionExpression:

() {
            var triState = 🔷isParenthesizedArrowFunctionExpression();
            if (triState === 0) {
                return undefined;
            }
            var arrowFunction = triState === 1
                ? 🔷parseParenthesizedArrowFunctionExpressionHead(true)
                : 🔶tryParse(parsePossibleParenthesizedArrowFunctionExpressionHead);
            if (!arrowFunction) {
                return undefined;
            }
            var isAsync = !!(ts.🔶️getModifierFlags(arrowFunction) & 256);
            var lastToken = 🔶token();
            arrowFunction.equalsGreaterThanToken = 🔶parseExpectedToken(35, false, ts.Diagnostics._0_expected, "=>");
            arrowFunction.body = (lastToken === 35 || lastToken ⚠️=== 16)
                ? 🔶parseArrowFunctionExpressionBody(isAsync)
                : 🔶parseIdentifier();
            return 🔶addJSDocComment(🔶finishNode(arrowFunction));
        }
Inlined functions:
isParenthesizedArrowFunctionExpression
() {
            if (🔷token() === 18 || 🔷token() === 26 || 🔷token() === 119) {
                return 🔷lookAhead(isParenthesizedArrowFunctionExpressionWorker);
            }
            if (🔷token() === 35) {
                return 1;
            }
            return 0;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
lookAhead
(callback) {
            return 🔶speculationHelper(callback, true);
        }
token
() {
            return currentToken;
        }
parseParenthesizedArrowFunctionExpressionHead
(allowAmbiguity) {
            var node = 🔷createNode(185);
            node.modifiers = 🔷parseModifiersForArrowFunction();
            var isAsync = !!(ts.🔷getModifierFlags(node) & 256);
            🔶fillSignature(55, false, isAsync, !allowAmbiguity, node);
            if (!node.parameters) {
                return undefined;
            }
            if (!allowAmbiguity && 🔶token() !== 35 && 🔶token() !== 16) {
                return undefined;
            }
            return node;
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseModifiersForArrowFunction
() {
            var modifiers;
            if (🔷token() === 119) {
                var modifierStart = scanner.⚠️getStartPos();
                var modifierKind = 🔶token();
                🔶nextToken();
                var modifier = 🔶finishNode(🔶createNode(modifierKind, modifierStart));
                modifiers = 🔶createNodeArray(⚠️[modifier], modifierStart);
                modifiers.end ⚠️= scanner.🔶getStartPos();
            }
            return modifiers;
        }
Inlined functions:
token
() {
            return currentToken;
        }
getModifierFlags
(node) {
        if (node⚠️.modifierFlagsCache & 536870912) {
            return node.modifierFlagsCache & ~536870912;
        }
        var flags = 0;
        if (node⚠️.modifiers) {
            for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
                var modifier = _a[_i];
                flags |= 🔷modifierToFlag(modifier.kind);
            }
        }
        if (node⚠️.flags & 4 || (node⚠️.kind === 70 && node⚠️.isInJSDocNamespace)) {
            flags |⚠️= 1;
        }
        node.modifierFlagsCache ⚠️= flags | 536870912;
        return flags;
    }
Inlined functions:
modifierToFlag
(token) {
        ⚠️switch (token) {
            case 114: return 32;
            case 113: return 4;
            case 112: return 16;
            case 111: return 8;
            case 116: return 128;
            case 83: return 1;
            case 123: return 2;
            case 75: return 2048;
            case 78: return 512;
            case 119: return 256;
            case 130: return 64;
        }
        return 0;
    }

isStartOfExpression:

() {
            if (🔶isStartOfLeftHandSideExpression()) {
                return true;
            }
            switch (🔷token()) {
                case 36:
                case 37:
                case 51:
                case 50:
                case 79:
                case 102:
                case 104:
                case 42:
                case 43:
                case 26:
                case 120:
                case 115:
                    return true;
                default:
                    if (🔷isBinaryOperator()) {
                        return true;
                    }
                    return 🔷isIdentifier();
            }
        }
Inlined functions:
token
() {
            return currentToken;
        }
isBinaryOperator
() {
            if (🔷inDisallowInContext() && 🔶token() ⚠️=== 91) {
                return false;
            }
            return 🔶getBinaryOperatorPrecedence() > 0;
        }
Inlined functions:
inDisallowInContext
() {
            return 🔷inContext(2048);
        }
Inlined functions:
inContext
(flags) {
            return (contextFlags & flags) !== 0;
        }
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

isDigit:

(ch) {
        return ch >= 48 && ch <= 57;
    }

parseConditionalExpressionRest:

~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
(leftOperand) {
            var questionToken = 🔷parseOptionalToken(54);
            if (!questionToken) {
                return leftOperand;
            }
            var node = 🔷createNode(193, leftOperand⚠️.pos);
            node.condition = leftOperand;
            node.questionToken = questionToken;
            node.whenTrue = 🔶doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher);
            node.colonToken = 🔶parseExpectedToken(55, false, ts.Diagnostics._0_expected, ts.🔶tokenToString(55));
            node.whenFalse = 🔶parseAssignmentExpressionOrHigher();
            return 🔶finishNode(node);
        }
Inlined functions:
parseOptionalToken
(t) {
            if (🔷token() === t) {
                return 🔷parseTokenNode();
            }
            return undefined;
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔷nextToken();
            return 🔷finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

isUnterminated:

() { return tokenIsUnterminated; }

parsePrimaryExpression:

~recompile~
~recompile~
() {
            switch (🔷token()) {
                case 8:
                case 9:
                case 12:
                    return 🔷parseLiteralNode();
                case 98:
                case 96:
                case 94:
                case 100:
                case 85:
                    return 🔷parseTokenNode();
                case 18:
                    return 🔷parseParenthesizedExpression();
                case 20:
                    return 🔶️parseArrayLiteralExpression();
                case 16:
                    return 🔶parseObjectLiteralExpression();
                case 119:
                    if (!🔶lookAhead(nextTokenIsFunctionKeywordOnSameLine)) {
                        break;
                    }
                    return 🔶️parseFunctionExpression();
                case 74:
                    return 🔶️parseClassExpression();
                case 88:
                    return 🔶️parseFunctionExpression();
                case 93:
                    return 🔶️parseNewExpression();
                case 40:
                case 62:
                    if (🔶️reScanSlashToken() === 11) {
                        return 🔶parseLiteralNode();
                    }
                    break;
                case 13:
                    return 🔶️parseTemplateExpression();
            }
            return 🔶parseIdentifier(ts.Diagnostics.Expression_expected);
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseLiteralNode
(internName) {
            return 🔶parseLiteralLikeNode(🔷token(), internName);
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔷nextToken();
            return 🔷finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }
parseParenthesizedExpression
() {
            var node = 🔷createNode(183);
            🔶parseExpected(18);
            node.expression = 🔶allowInAnd(parseExpression);
            🔶parseExpected(19);
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

hasModifier:

~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
(node, flags) {
        return (🔷getModifierFlags(node) & flags) !== 0;
    }
Inlined functions:
getModifierFlags
(node) {
        if (node⚠️.modifierFlagsCache & 536870912) {
            return node⚠️.modifierFlagsCache & ~536870912;
        }
        var flags = 0;
        if (node⚠️.modifiers) {
            for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
                var modifier = _a[_i];
                flags |= 🔷modifierToFlag(modifier.kind);
            }
        }
        if (node⚠️.flags & 4 || (node⚠️.kind === 70 && node⚠️.isInJSDocNamespace)) {
            flags |⚠️= 1;
        }
        node.modifierFlagsCache ⚠️= flags | 536870912;
        return flags;
    }
Inlined functions:
modifierToFlag
(token) {
        switch (token) {
            case 114: return 32;
            case 113: return 4;
            case 112: return 16;
            case 111: return 8;
            case 116: return 128;
            case 83: return 1;
            case 123: return 2;
            case 75: return 2048;
            case 78: return 512;
            case 119: return 256;
            case 130: return 64;
        }
        return 0;
    }

setDisallowInContext:

(val) {
            🔷setContextFlag(val, 2048);
        }
Inlined functions:
setContextFlag
(val, flag) {
            if (val) {
                contextFlags |= flag;
            }
            else {
                contextFlags &= ~flag;
            }
        }

parseArgumentExpression:

() {
            return 🔷doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement);
        }
Inlined functions:
doOutsideOfContext
(context, func) {
            var contextFlagsToClear = context & contextFlags;
            if (contextFlagsToClear) {
                🔶setContextFlag(false, contextFlagsToClear);
                var result = 🔶️func();
                🔶setContextFlag(true, contextFlagsToClear);
                return result;
            }
            return 🔶️func();
        }

parseArgumentOrArrayLiteralElement:

() {
            return 🔷token() === 23 ? 🔶️parseSpreadElement() :
                🔷token() === 25 ? 🔶createNode(198) :
                    🔶parseAssignmentExpressionOrHigher();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

isStartOfStatement:

() {
            switch (🔷token()) {
                case 56:
                case 24:
                case 16:
                case 103:
                case 109:
                case 88:
                case 74:
                case 82:
                case 89:
                case 80:
                case 105:
                case 87:
                case 76:
                case 71:
                case 95:
                case 106:
                case 97:
                case 99:
                case 101:
                case 77:
                case 73:
                case 86:
                    return true;
                case 75:
                case 83:
                case 90:
                    return 🔷isStartOfDeclaration();
                case 119:
                case 123:
                case 108:
                case 127:
                case 128:
                case 136:
                case 139:
                    return true;
                case 113:
                case 111:
                case 112:
                case 114:
                case 130:
                    return 🔶isStartOfDeclaration() || !🔶lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
                default:
                    return 🔶isStartOfExpression();
            }
        }
Inlined functions:
token
() {
            return currentToken;
        }
isStartOfDeclaration
() {
            return 🔷lookAhead(isDeclaration);
        }
Inlined functions:
lookAhead
(callback) {
            return 🔶speculationHelper(callback, true);
        }

allowInAnd:

(func) {
            return 🔷doOutsideOfContext(2048, func);
        }
Inlined functions:
doOutsideOfContext
(context, func) {
            var contextFlagsToClear = context & contextFlags;
            if (contextFlagsToClear) {
                🔶setContextFlag(false, contextFlagsToClear);
                var result = 🔶️func();
                🔶setContextFlag(true, contextFlagsToClear);
                return result;
            }
            return 🔶️func();
        }

parseArgumentList:

() {
            🔷parseExpected(18);
            var result = 🔶parseDelimitedList(11, parseArgumentExpression);
            🔷parseExpected(19);
            return result;
        }
Inlined functions:
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

isIdentifierOrPattern:

() {
            return 🔷token() === 16 || 🔷token() === 20 || 🔷isIdentifier();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

parseUnionTypeOrHigher:

~recompile~
~recompile~
~recompile~
() {
            return 🔷parseUnionOrIntersectionType(164, parseIntersectionTypeOrHigher, 48);
        }
Inlined functions:
parseUnionOrIntersectionType
(kind, parseConstituentType, operator) {
            🔷parseOptional(operator);
            var type = 🔶️parseConstituentType();
            if (🔷token() === operator) {
                var types = 🔷createNodeArray([type], type⚠️.pos);
                while (🔷parseOptional(operator)) {
                    types.push(🔶️parseConstituentType());
                }
                types.end = 🔷getNodeEnd();
                var node = 🔷createNode(kind, type⚠️.pos);
                node.types = types;
                type = 🔷finishNode(node);
            }
            return type;
        }
Inlined functions:
parseOptional
(t) {
            if (🔷token() === t) {
                🔷nextToken();
                return true;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
token
() {
            return currentToken;
        }
createNodeArray
(elements, pos) {
            var array = (elements || []);
            if (!(pos >= 0)) {
                pos = 🔷getNodePos();
            }
            array.pos ⚠️= pos;
            array.end = pos;
            return array;
        }
Inlined functions:
getNodePos
() {
            return scanner.🔶getStartPos();
        }
parseOptional
(t) {
            if (🔷token() === t) {
                🔷nextToken();
                return true;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
getNodeEnd
() {
            return scanner.🔶getStartPos();
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }

parsePropertyOrMethodDeclaration:

(fullStart, decorators, modifiers) {
            var asteriskToken = 🔷parseOptionalToken(38);
            var name = 🔷parsePropertyName();
            var questionToken = 🔶parseOptionalToken(54);
            if (asteriskToken || 🔶token() === 18 || 🔶token() === 26) {
                return 🔶parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, name, questionToken, ts.Diagnostics.or_expected);
            }
            else {
                return 🔶parsePropertyDeclaration(fullStart, decorators, modifiers, name, questionToken);
            }
        }
Inlined functions:
parseOptionalToken
(t) {
            if (🔷token() === t) {
                return 🔷parseTokenNode();
            }
            return undefined;
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔷nextToken();
            return 🔷finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }
parsePropertyName
() {
            return 🔷parsePropertyNameWorker(true);
        }
Inlined functions:
parsePropertyNameWorker
(allowComputedPropertyNames) {
            if (🔷token() === 9 || 🔷token() === 8) {
                return 🔷parseLiteralNode(true);
            }
            if (allowComputedPropertyNames && 🔷token() === 20) {
                return 🔶️parseComputedPropertyName();
            }
            return 🔷parseIdentifierName();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseLiteralNode
(internName) {
            return 🔶parseLiteralLikeNode(🔷token(), internName);
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseIdentifierName
() {
            return 🔷createIdentifier(ts.🔷tokenIsIdentifierOrKeyword(🔷token()));
        }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
createIdentifier
(isIdentifier, diagnosticMessage) {
            identifierCount++;
            if (isIdentifier) {
                var node = 🔷createNode(70);
                if (🔷token() !== 70) {
                    node.originalKeywordKind = 🔷token();
                }
                node.text = 🔷internIdentifier(scanner.🔶getTokenValue());
                🔷nextToken();
                return 🔷finishNode(node);
            }
            return 🔶️createMissingNode(70, false, diagnosticMessage || ts⚠️.Diagnostics⚠️.Identifier_expected);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔶️new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔶️new IdentifierConstructor(kind, pos, pos) :
                    🔶️new TokenConstructor(kind, pos, pos);
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
internIdentifier
(text) {
            text = ts.🔶escapeIdentifier(text);
            return identifiers⚠️[text] || (identifiers[text] ⚠️= text);
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }

parseStatement:

() {
            switch (🔷token()) {
                case 24:
                    return 🔶️parseEmptyStatement();
                case 16:
                    return 🔷parseBlock(false);
                case 103:
                    return 🔶️parseVariableStatement(scanner.🔶getStartPos(), undefined, undefined);
                case 109:
                    if (🔶️isLetDeclaration()) {
                        return 🔶️parseVariableStatement(scanner.🔶getStartPos(), undefined, undefined);
                    }
                    break;
                case 88:
                    return 🔶parseFunctionDeclaration(scanner.🔶getStartPos(), undefined, undefined);
                case 74:
                    return 🔶️parseClassDeclaration(scanner.🔶getStartPos(), undefined, undefined);
                case 89:
                    return 🔶️parseIfStatement();
                case 80:
                    return 🔶️parseDoStatement();
                case 105:
                    return 🔶️parseWhileStatement();
                case 87:
                    return 🔶️parseForOrForInOrForOfStatement();
                case 76:
                    return 🔶️parseBreakOrContinueStatement(214);
                case 71:
                    return 🔶️parseBreakOrContinueStatement(215);
                case 95:
                    return 🔶parseReturnStatement();
                case 106:
                    return 🔶️parseWithStatement();
                case 97:
                    return 🔶️parseSwitchStatement();
                case 99:
                    return 🔶️parseThrowStatement();
                case 101:
                case 73:
                case 86:
                    return 🔶️parseTryStatement();
                case 77:
                    return 🔶️parseDebuggerStatement();
                case 56:
                    return 🔶parseDeclaration();
                case 119:
                case 108:
                case 136:
                case 127:
                case 128:
                case 123:
                case 75:
                case 82:
                case 83:
                case 90:
                case 111:
                case 112:
                case 113:
                case 116:
                case 114:
                case 130:
                case 139:
                    if (🔶isStartOfDeclaration()) {
                        return 🔶parseDeclaration();
                    }
                    break;
            }
            return 🔶️parseExpressionOrLabeledStatement();
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseBlock
(ignoreMissingOpenBrace, diagnosticMessage) {
            var node = 🔷createNode(204);
            if (🔷parseExpected(16, diagnosticMessage) || ignoreMissingOpenBrace) {
                if (scanner.🔶hasPrecedingLineBreak()) {
                    node.multiLine = true;
                }
                node.statements = 🔶parseList(1, parseStatement);
                🔷parseExpected(17);
            }
            else {
                node.statements ⚠️= createMissingList();
            }
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

parseTypeOrTypePredicate:

() {
            var typePredicateVariable = 🔷isIdentifier() && 🔷tryParse(parseTypePredicatePrefix);
            var type = 🔷parseType();
            if (typePredicateVariable) {
                var node = 🔷createNode(156, typePredicateVariable⚠️.pos);
                node.parameterName ⚠️= typePredicateVariable;
                node.type ⚠️= type;
                return 🔷finishNode(node);
            }
            else {
                return type;
            }
        }
Inlined functions:
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
tryParse
(callback) {
            return 🔶speculationHelper(callback, false);
        }
parseType
() {
            return 🔷doOutsideOfContext(20480, parseTypeWorker);
        }
Inlined functions:
doOutsideOfContext
(context, func) {
            var contextFlagsToClear = context & contextFlags;
            if (contextFlagsToClear) {
                🔶setContextFlag(false, contextFlagsToClear);
                var result = 🔶️func();
                🔶setContextFlag(true, contextFlagsToClear);
                return result;
            }
            return 🔶️func();
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }

parseFunctionBlockOrSemicolon:

(isGenerator, isAsync, diagnosticMessage) {
            if (🔷token() !== 16 && 🔷canParseSemicolon()) {
                🔷parseSemicolon();
                return;
            }
            return 🔶parseFunctionBlock(isGenerator, isAsync, false, diagnosticMessage);
        }
Inlined functions:
token
() {
            return currentToken;
        }
canParseSemicolon
() {
            if (🔷token() === 24) {
                return true;
            }
            return 🔷token() === 17 || 🔷token() === 1 || scanner.🔶hasPrecedingLineBreak();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseSemicolon
() {
            if (🔷canParseSemicolon()) {
                if (🔷token() === 24) {
                    🔷nextToken();
                }
                return true;
            }
            else {
                return 🔶parseExpected(24);
            }
        }
Inlined functions:
canParseSemicolon
() {
            if (🔷token() === 24) {
                return true;
            }
            return 🔷token() === 17 || 🔷token() === 1 || scanner.🔶hasPrecedingLineBreak();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }

loadModuleFromFile:

~recompile~
~recompile~
(extensions, candidate, failedLookupLocations, onlyRecordFailures, state) {
        var resolvedByAddingExtension = 🔶tryAddingExtensions(candidate, extensions, failedLookupLocations, onlyRecordFailures, state);
        if (resolvedByAddingExtension) {
            return resolvedByAddingExtension;
        }
        if (ts.🔶hasJavaScriptFileExtension(candidate)) {
            var extensionless = ts.🔷removeFileExtension(candidate);
            if (state.traceEnabled) {
                var extension = candidate.🔶substring(extensionless⚠️.length);
                🔶️trace(state⚠️.host, ts⚠️.Diagnostics⚠️.File_name_0_has_a_1_extension_stripping_it, candidate, extension);
            }
            return 🔶tryAddingExtensions(extensionless, extensions, failedLookupLocations, onlyRecordFailures, state);
        }
    }
Inlined functions:
removeFileExtension
(path) {
        for (var _i = 0, extensionsToRemove_1 = extensionsToRemove; _i < extensionsToRemove_1.length; _i++) {
            var ext = extensionsToRemove_1[_i];
            var extensionless = 🔷tryRemoveExtension(path, ext);
            if (extensionless !== undefined) {
                return extensionless;
            }
        }
        return path;
    }
Inlined functions:
tryRemoveExtension
(path, extension) {
        return 🔷fileExtensionIs(path, extension) ? 🔷removeExtension(path, extension) : undefined;
    }
Inlined functions:
fileExtensionIs
(path, extension) {
        return path.length > extension.length && 🔷endsWith(path, extension);
    }
Inlined functions:
endsWith
(str, suffix) {
        var expectedPos = str.length - suffix.length;
        return expectedPos >= 0 && str.🔶indexOf(suffix, expectedPos) === expectedPos;
    }
removeExtension
(path, extension) {
        return path.🔶substring(0, path.length - extension.length);
    }

tryExtension:

~recompile~
~recompile~
~recompile~
(ext, extension) {
            var path = 🔷tryFile(candidate + ext, failedLookupLocations, onlyRecordFailures, state);
            return path && { path: path, extension: extension };
        }
Inlined functions:
tryFile
(fileName, failedLookupLocations, onlyRecordFailures, state) {
        if (!onlyRecordFailures && state.host.🔶fileExists(fileName)) {
            if (state.traceEnabled) {
                🔶️trace(state⚠️.host, ts⚠️.Diagnostics⚠️.File_0_exist_use_it_as_a_name_resolution_result, fileName);
            }
            return fileName;
        }
        else {
            if (state.traceEnabled) {
                🔶️trace(state⚠️.host, ts⚠️.Diagnostics⚠️.File_0_does_not_exist, fileName);
            }
            failedLookupLocations.🔶️push(fileName);
            return undefined;
        }
    }

normalizePath:

(path) {
        path = 🔷normalizeSlashes(path);
        var rootLength = 🔶getRootLength(path);
        var root = path.🔶substr(0, rootLength);
        var normalized = 🔶getNormalizedParts(path, rootLength);
        if (normalized.length) {
            var joinedParts = root + normalized.🔶join(ts.directorySeparator);
            return 🔷pathEndsWithDirectorySeparator(path) ? joinedParts ⚠️+ ts⚠️.directorySeparator : joinedParts;
        }
        else {
            return root;
        }
    }
Inlined functions:
normalizeSlashes
(path) {
        return path.⚠️replace(🔶️/\x5c\x5c/g, "/");
    }
pathEndsWithDirectorySeparator
(path) {
        return path.charCodeAt(path.length - 1) === directorySeparatorCharCode;
    }

parseLiteralNode:

(internName) {
            return 🔶parseLiteralLikeNode(🔷token(), internName);
        }
Inlined functions:
token
() {
            return currentToken;
        }

parseObjectTypeMembers:

() {
            var members;
            if (🔷parseExpected(16)) {
                members = 🔶parseList(4, parseTypeMember);
                🔷parseExpected(17);
            }
            else {
                members = 🔶️createMissingList();
            }
            return members;
        }
Inlined functions:
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

scanJsxIdentifier:

() {
            return currentToken = scanner.🔶scanJsxIdentifier();
        }

hasJavaScriptFileExtension:

(fileName) {
        return 🔷forEach(ts.supportedJavascriptExtensions, 🔶️function (extension) { return fileExtensionIs(fileName, extension); });
    }
Inlined functions:
forEach
(array, callback) {
        if (array) {
            for (var i = 0, len = array.length; i < len; i++) {
                var result = 🔶️callback(array[i], i);
                if (result) {
                    return result;
                }
            }
        }
        return undefined;
    }

directoryExists:

~recompile~
~recompile~
(directoryName) { return ts.sys.🔶directoryExists(directoryName); }

directoryProbablyExists:

(directoryName, host) {
        return !host.directoryExists || host.🔶directoryExists(directoryName);
    }

tryParseAccessorDeclaration:

(fullStart, decorators, modifiers) {
            if (🔷parseContextualModifier(124)) {
                return 🔷parseAccessorDeclaration(151, fullStart, decorators, modifiers);
            }
            else if (🔶parseContextualModifier(133)) {
                return 🔶️parseAccessorDeclaration(152, fullStart, decorators, modifiers);
            }
            return undefined;
        }
Inlined functions:
parseContextualModifier
(t) {
            return 🔷token() === t && 🔷tryParse(nextTokenCanFollowModifier);
        }
Inlined functions:
token
() {
            return currentToken;
        }
tryParse
(callback) {
            return 🔶speculationHelper(callback, false);
        }
parseAccessorDeclaration
(kind, fullStart, decorators, modifiers) {
            var node = 🔷createNode(kind, fullStart);
            node.decorators = decorators;
            node.modifiers = modifiers;
            node.name = 🔷parsePropertyName();
            🔶fillSignature(55, false, false, false, node);
            node.body = 🔶parseFunctionBlockOrSemicolon(false, false);
            return 🔶addJSDocComment(🔶finishNode(node));
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parsePropertyName
() {
            return 🔷parsePropertyNameWorker(true);
        }
Inlined functions:
parsePropertyNameWorker
(allowComputedPropertyNames) {
            if (🔷token() === 9 || 🔷token() === 8) {
                return 🔷parseLiteralNode(true);
            }
            if (allowComputedPropertyNames && 🔷token() === 20) {
                return 🔷parseComputedPropertyName();
            }
            return 🔶parseIdentifierName();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseLiteralNode
(internName) {
            return 🔶parseLiteralLikeNode(🔷token(), internName);
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseComputedPropertyName
() {
            var node = 🔷createNode(142);
            🔷parseExpected(20);
            node.expression = 🔷allowInAnd(parseExpression);
            🔷parseExpected(21);
            return 🔷finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔶️new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔶️new IdentifierConstructor(kind, pos, pos) :
                    🔶️new TokenConstructor(kind, pos, pos);
        }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔶token() === kind) {
                if (shouldAdvance) {
                    🔶nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔶️parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔶tokenToString(kind));
            }
            return false;
        }
allowInAnd
(func) {
            return 🔶doOutsideOfContext(2048, func);
        }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔶token() === kind) {
                if (shouldAdvance) {
                    🔶nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔶️parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔶tokenToString(kind));
            }
            return false;
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }

getDirectoryPath:

(path) {
        return path.🔶substr(0, Math.max(🔶getRootLength(path), path.🔶lastIndexOf(ts.directorySeparator)));
    }

isKeyword:

(token) {
        return 71 <= token && token <= 140;
    }

getTextPos:

() { return pos; }

canFollowModifier:

() {
            return 🔷token() === 20
                || 🔷token() === 16
                || 🔷token() === 38
                || 🔷token() === 23
                || 🔷isLiteralPropertyName();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isLiteralPropertyName
() {
            return ts.🔷tokenIsIdentifierOrKeyword(🔷token()) ||
                🔷token() === 9 ||
                🔷token() === 8;
        }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

parseTypeParameter:

() {
            var node = 🔷createNode(143);
            node.name = 🔷parseIdentifier();
            if (🔶parseOptional(84)) {
                if (🔶isStartOfType() || !🔶isStartOfExpression()) {
                    node.constraint = 🔶parseType();
                }
                else {
                    node.expression ⚠️= parseUnaryExpressionOrHigher();
                }
            }
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseIdentifier
(diagnosticMessage) {
            return 🔷createIdentifier(🔷isIdentifier(), diagnosticMessage);
        }
Inlined functions:
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
createIdentifier
(isIdentifier, diagnosticMessage) {
            identifierCount++;
            if (isIdentifier) {
                var node = 🔷createNode(70);
                if (🔶token() !== 70) {
                    node.originalKeywordKind = 🔶token();
                }
                node.text = 🔶️internIdentifier(scanner.🔶getTokenValue());
                🔶nextToken();
                return 🔶finishNode(node);
            }
            return 🔶️createMissingNode(70, false, diagnosticMessage || ts⚠️.Diagnostics⚠️.Identifier_expected);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

parseTypePredicatePrefix:

() {
            var id = 🔷parseIdentifier();
            if (🔶token() === 125 && !scanner.🔶hasPrecedingLineBreak()) {
                🔶nextToken();
                return id;
            }
        }
Inlined functions:
parseIdentifier
(diagnosticMessage) {
            return 🔷createIdentifier(🔷isIdentifier(), diagnosticMessage);
        }
Inlined functions:
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
createIdentifier
(isIdentifier, diagnosticMessage) {
            identifierCount++;
            if (isIdentifier) {
                var node = 🔷createNode(70);
                if (🔷token() !== 70) {
                    node.originalKeywordKind = 🔷token();
                }
                node.text = 🔷internIdentifier(scanner.getTokenValue());
                🔷nextToken();
                return 🔷finishNode(node);
            }
            return 🔷createMissingNode(70, false, diagnosticMessage || ts⚠️.Diagnostics⚠️.Identifier_expected);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
internIdentifier
(text) {
            text = ts.🔷escapeIdentifier(text);
            return identifiers⚠️[text] || (identifiers[text] ⚠️= text);
        }
Inlined functions:
escapeIdentifier
(identifier) {
        return identifier⚠️.length >= 2 && identifier.🔶️charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 ? "_" + identifier : identifier;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }
createMissingNode
(kind, reportAtCurrentPosition, diagnosticMessage, arg0) {
            if (reportAtCurrentPosition) {
                🔶️parseErrorAtPosition(scanner.🔶getStartPos(), 0, diagnosticMessage, arg0);
            }
            else {
                🔷parseErrorAtCurrentToken(diagnosticMessage, arg0);
            }
            var result = 🔶createNode(kind, scanner.🔶getStartPos());
            result.text = "";
            return 🔶finishNode(result);
        }
Inlined functions:
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔶lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }

isStartOfDeclaration:

() {
            return 🔷lookAhead(isDeclaration);
        }
Inlined functions:
lookAhead
(callback) {
            return 🔶speculationHelper(callback, true);
        }

nextTokenIsOnSameLineAndCanFollowModifier:

() {
            🔷nextToken();
            if (scanner.🔶hasPrecedingLineBreak()) {
                return false;
            }
            return 🔷canFollowModifier();
        }
Inlined functions:
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
canFollowModifier
() {
            return 🔷token() === 20
                || 🔷token() === 16
                || 🔷token() === 38
                || 🔷token() === 23
                || 🔷isLiteralPropertyName();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isLiteralPropertyName
() {
            return ts.🔷tokenIsIdentifierOrKeyword(🔷token()) ||
                🔷token() === 9 ||
                🔷token() === 8;
        }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

parsePropertyDeclaration:

(fullStart, decorators, modifiers, name, questionToken) {
            var property = 🔷createNode(147, fullStart);
            property.decorators = decorators;
            property.modifiers = modifiers;
            property.name = name;
            property.questionToken = questionToken;
            property.type = 🔷parseTypeAnnotation();
            property.initializer = ts.🔷hasModifier(property, 32)
                ? 🔶allowInAnd(parseNonParameterInitializer)
                : 🔶doOutsideOfContext(4096 | 2048, parseNonParameterInitializer);
            🔶parseSemicolon();
            return 🔶addJSDocComment(🔶finishNode(property));
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseTypeAnnotation
() {
            return 🔷parseOptional(55) ? 🔷parseType() : undefined;
        }
Inlined functions:
parseOptional
(t) {
            if (🔷token() === t) {
                🔷nextToken();
                return true;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
parseType
() {
            return 🔷doOutsideOfContext(20480, parseTypeWorker);
        }
Inlined functions:
doOutsideOfContext
(context, func) {
            var contextFlagsToClear = context & contextFlags;
            if (contextFlagsToClear) {
                🔶setContextFlag(false, contextFlagsToClear);
                var result = 🔶️func();
                🔶setContextFlag(true, contextFlagsToClear);
                return result;
            }
            return 🔶️func();
        }
hasModifier
(node, flags) {
        return (🔷getModifierFlags(node) & flags) !== 0;
    }
Inlined functions:
getModifierFlags
(node) {
        if (node⚠️.modifierFlagsCache & 536870912) {
            return node.modifierFlagsCache & ~536870912;
        }
        var flags = 0;
        if (node⚠️.modifiers) {
            for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
                var modifier = _a[_i];
                flags |= 🔷modifierToFlag(modifier.kind);
            }
        }
        if (node⚠️.flags & 4 || (node⚠️.kind === 70 && node⚠️.isInJSDocNamespace)) {
            flags |⚠️= 1;
        }
        node.modifierFlagsCache ⚠️= flags | 536870912;
        return flags;
    }
Inlined functions:
modifierToFlag
(token) {
        switch (token) {
            case 114: return 32;
            case 113: return 4;
            case 112: return 16;
            case 111: return 8;
            case 116: return 128;
            case 83: return 1;
            case 123: return 2;
            case 75: return 2048;
            case 78: return 512;
            case 119: return 256;
            case 130: return 64;
        }
        return 0;
    }

parseMethodDeclaration:

(fullStart, decorators, modifiers, asteriskToken, name, questionToken, diagnosticMessage) {
            var method = 🔷createNode(149, fullStart);
            method.decorators = decorators;
            method.modifiers = modifiers;
            method.asteriskToken = asteriskToken;
            method.name = name;
            method.questionToken = questionToken;
            var isGenerator = !!asteriskToken;
            var isAsync = ts.🔷hasModifier(method, 256);
            🔶fillSignature(55, isGenerator, isAsync, false, method);
            method.body ⚠️= parseFunctionBlockOrSemicolon(isGenerator, isAsync, diagnosticMessage);
            return 🔶addJSDocComment(🔶finishNode(method));
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
hasModifier
(node, flags) {
        return (🔷getModifierFlags(node) & flags) !== 0;
    }
Inlined functions:
getModifierFlags
(node) {
        if (node⚠️.modifierFlagsCache & 536870912) {
            return node.modifierFlagsCache & ~536870912;
        }
        var flags = 0;
        if (node⚠️.modifiers) {
            for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
                var modifier = _a[_i];
                flags |= 🔷modifierToFlag(modifier.kind);
            }
        }
        if (node⚠️.flags & 4 || (node⚠️.kind === 70 && node⚠️.isInJSDocNamespace)) {
            flags |⚠️= 1;
        }
        node.modifierFlagsCache ⚠️= flags | 536870912;
        return flags;
    }
Inlined functions:
modifierToFlag
(token) {
        switch (token) {
            case 114: return 32;
            case 113: return 4;
            case 112: return 16;
            case 111: return 8;
            case 116: return 128;
            case 83: return 1;
            case 123: return 2;
            case 75: return 2048;
            case 78: return 512;
            case 119: return 256;
            case 130: return 64;
        }
        return 0;
    }
parseFunctionBlockOrSemicolon
(isGenerator, isAsync, diagnosticMessage) {
            if (🔷token() !== 16 && 🔷canParseSemicolon()) {
                🔶parseSemicolon();
                return;
            }
            return 🔶parseFunctionBlock(isGenerator, isAsync, false, diagnosticMessage);
        }
Inlined functions:
token
() {
            return currentToken;
        }
canParseSemicolon
() {
            if (🔷token() === 24) {
                return true;
            }
            return 🔷token() === 17 || 🔷token() === 1 || scanner.🔶hasPrecedingLineBreak();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

parseParameter:

() {
            var node = 🔷createNode(144);
            if (🔷token() === 98) {
                node.name = 🔷createIdentifier(true, undefined);
                node.type = 🔶parseParameterType();
                return 🔶finishNode(node);
            }
            node.decorators = 🔶parseDecorators();
            node.modifiers = 🔶parseModifiers();
            node.dotDotDotToken = 🔶parseOptionalToken(23);
            node.name = 🔶parseIdentifierOrPattern();
            if (ts.🔶getFullWidth(node.name) === 0 && !ts.🔶️hasModifiers(node) && ts.⚠️isModifierKind(🔶token())) {
                🔶nextToken();
            }
            node.questionToken = 🔶parseOptionalToken(54);
            node.type = 🔶parseParameterType();
            node.initializer = 🔶parseBindingElementInitializer(true);
            return 🔶addJSDocComment(🔶finishNode(node));
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
token
() {
            return currentToken;
        }
createIdentifier
(isIdentifier, diagnosticMessage) {
            identifierCount++;
            if (isIdentifier) {
                var node = 🔷createNode(70);
                if (🔶token() !== 70) {
                    node.originalKeywordKind = 🔶token();
                }
                node.text = 🔶️internIdentifier(scanner.🔶getTokenValue());
                🔶nextToken();
                return 🔶finishNode(node);
            }
            return 🔶️createMissingNode(70, false, diagnosticMessage || ts⚠️.Diagnostics⚠️.Identifier_expected);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

parseDeclaration:

() {
            var fullStart = 🔷getNodePos();
            var decorators = parseDecorators();
            var modifiers = parseModifiers();
            switch (🔷token()) {
                case 103:
                case 109:
                case 75:
                    return 🔷parseVariableStatement(fullStart, decorators, modifiers);
                case 88:
                    return 🔶parseFunctionDeclaration(fullStart, decorators, modifiers);
                case 74:
                    return 🔷parseClassDeclaration(fullStart, decorators, modifiers);
                case 108:
                    return 🔷parseInterfaceDeclaration(fullStart, decorators, modifiers);
                case 136:
                    return 🔶parseTypeAliasDeclaration(fullStart, decorators, modifiers);
                case 82:
                    return 🔶️parseEnumDeclaration(fullStart, decorators, modifiers);
                case 139:
                case 127:
                case 128:
                    return 🔶️parseModuleDeclaration(fullStart, decorators, modifiers);
                case 90:
                    return 🔶️parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers);
                case 83:
                    🔶nextToken();
                    switch (🔶token()) {
                        case 78:
                        case 57:
                            return 🔶️parseExportAssignment(fullStart, decorators, modifiers);
                        case 117:
                            return 🔶️parseNamespaceExportDeclaration(fullStart, decorators, modifiers);
                        default:
                            return 🔶️parseExportDeclaration(fullStart, decorators, modifiers);
                    }
                default:
                    if (decorators || modifiers) {
                        var node = 🔶️createMissingNode(244, true, ts⚠️.Diagnostics⚠️.Declaration_expected);
                        node.pos ⚠️= fullStart;
                        node.decorators ⚠️= decorators;
                        node.modifiers ⚠️= modifiers;
                        return 🔶finishNode(node);
                    }
            }
        }
Inlined functions:
getNodePos
() {
            return scanner.getStartPos();
        }
token
() {
            return currentToken;
        }
parseVariableStatement
(fullStart, decorators, modifiers) {
            var node = 🔷createNode(205, fullStart);
            node.decorators = decorators;
            node.modifiers = modifiers;
            node.declarationList = 🔶parseVariableDeclarationList(false);
            🔷parseSemicolon();
            return 🔶addJSDocComment(🔷finishNode(node));
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseSemicolon
() {
            if (🔷canParseSemicolon()) {
                if (🔷token() === 24) {
                    🔷nextToken();
                }
                return true;
            }
            else {
                return 🔶parseExpected(24);
            }
        }
Inlined functions:
canParseSemicolon
() {
            if (🔷token() === 24) {
                return true;
            }
            return 🔷token() === 17 || 🔷token() === 1 || scanner.🔶hasPrecedingLineBreak();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }
parseClassDeclaration
(fullStart, decorators, modifiers) {
            return 🔶parseClassDeclarationOrExpression(fullStart, decorators, modifiers, 226);
        }
parseInterfaceDeclaration
(fullStart, decorators, modifiers) {
            var node = 🔷createNode(227, fullStart);
            node.decorators = decorators;
            node.modifiers = modifiers;
            🔶parseExpected(108);
            node.name = 🔶parseIdentifier();
            node.typeParameters = 🔶parseTypeParameters();
            node.heritageClauses = 🔶parseHeritageClauses();
            node.members = 🔶parseObjectTypeMembers();
            return 🔶addJSDocComment(🔶finishNode(node));
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔶️new IdentifierConstructor(kind, pos, pos) :
                    🔶️new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

parseHeritageClauses:

() {
            if (🔷isHeritageClause()) {
                return 🔶parseList(21, parseHeritageClause);
            }
            return undefined;
        }
Inlined functions:
isHeritageClause
() {
            return 🔷token() === 84 || 🔷token() === 107;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

makeBinaryExpression:

(left, operatorToken, right) {
            var node = 🔷createNode(192, left⚠️.pos);
            node.left = left;
            node.operatorToken = operatorToken;
            node.right = right;
            return 🔷finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }

isRootedDiskPath:

(path) {
        return 🔶getRootLength(path) !== 0;
    }

scanString:

(allowEscapes) {
            if (allowEscapes === void 0) { allowEscapes = true; }
            var quote = text.charCodeAt(pos);
            pos++;
            var result = "";
            var start = pos;
            while (true) {
                if (pos >= end) {
                    result +⚠️= text.⚠️substring(start, pos);
                    tokenIsUnterminated = true;
                    🔶️error(ts⚠️.Diagnostics⚠️.Unterminated_string_literal);
                    break;
                }
                var ch = text.charCodeAt(pos);
                if (ch === quote) {
                    result += text.🔶substring(start, pos);
                    pos++;
                    break;
                }
                if (ch === 92 && allowEscapes) {
                    result += text.⚠️substring(start, pos);
                    result += 🔶️scanEscapeSequence();
                    start = pos;
                    continue;
                }
                if (🔷isLineBreak(ch)) {
                    result +⚠️= text.⚠️substring(start, pos);
                    tokenIsUnterminated = true;
                    🔶️error(ts⚠️.Diagnostics⚠️.Unterminated_string_literal);
                    break;
                }
                pos++;
            }
            return result;
        }
Inlined functions:
isLineBreak
(ch) {
        return ch === 10 ||
            ch === 13 ||
            ch === 8232 ||
            ch === 8233;
    }

parseMemberExpressionRest:

~recompile~
~recompile~
~recompile~
(expression) {
            while (true) {
                var dotToken = 🔷parseOptionalToken(22);
                if (dotToken) {
                    var propertyAccess = 🔷createNode(177, expression⚠️.pos);
                    propertyAccess.expression = expression;
                    propertyAccess.name = 🔶parseRightSideOfDot(true);
                    expression = 🔶finishNode(propertyAccess);
                    continue;
                }
                if (🔶token() === 50 && !scanner.🔶hasPrecedingLineBreak()) {
                    🔶nextToken();
                    var nonNullExpression = 🔶createNode(201, expression.pos);
                    nonNullExpression.expression = expression;
                    expression = 🔶finishNode(nonNullExpression);
                    continue;
                }
                if (!🔶inDecoratorContext() && 🔶parseOptional(20)) {
                    var indexedAccess = createNode(178, expression.pos);
                    indexedAccess.expression = expression;
                    if (🔶token() !== 21) {
                        indexedAccess.argumentExpression = 🔶allowInAnd(parseExpression);
                        if (indexedAccess.argumentExpression⚠️.kind === 9 || indexedAccess.argumentExpression⚠️.kind === 8) {
                            var literal = indexedAccess.argumentExpression;
                            literal.text = 🔶️internIdentifier(literal.text);
                        }
                    }
                    🔶parseExpected(21);
                    expression = 🔶finishNode(indexedAccess);
                    continue;
                }
                if (🔶token() === 12 || 🔶token() === 13) {
                    var tagExpression = 🔶createNode(181, expression⚠️.pos);
                    tagExpression.tag ⚠️= expression;
                    tagExpression.template ⚠️= token() ⚠️=== 12
                        ? 🔶parseLiteralNode()
                        : 🔶️parseTemplateExpression();
                    expression = 🔶finishNode(tagExpression);
                    continue;
                }
                return expression;
            }
        }
Inlined functions:
parseOptionalToken
(t) {
            if (🔷token() === t) {
                return 🔷parseTokenNode();
            }
            return undefined;
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔷nextToken();
            return 🔷finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

parseLiteralLikeNode:

(kind, internName) {
            var node = 🔷createNode(kind);
            var text = scanner.getTokenValue();
            node.text = internName ? 🔷internIdentifier(text) : text;
            if (scanner.🔶hasExtendedUnicodeEscape()) {
                node.hasExtendedUnicodeEscape ⚠️= true;
            }
            if (scanner.🔶isUnterminated()) {
                node.isUnterminated ⚠️= true;
            }
            var tokenPos = scanner.🔶getTokenPos();
            🔷nextToken();
            🔷finishNode(node);
            if (node.kind === 8
                && sourceText.charCodeAt(tokenPos) === 48
                && ts.🔷isOctalDigit(sourceText.charCodeAt(tokenPos + 1))) {
                node.isOctalLiteral ⚠️= true;
            }
            return node;
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
internIdentifier
(text) {
            text = ts.🔷escapeIdentifier(text);
            return identifiers⚠️[text] || (identifiers[text] ⚠️= text);
        }
Inlined functions:
escapeIdentifier
(identifier) {
        return identifier⚠️.length >= 2 && identifier.🔶️charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 ? "_" + identifier : identifier;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }
isOctalDigit
(ch) {
        return ch >= 48 && ch <= 55;
    }

hasExtendedUnicodeEscape:

() { return hasExtendedUnicodeEscape; }

inYieldContext:

() {
            return 🔷inContext(4096);
        }
Inlined functions:
inContext
(flags) {
            return (contextFlags & flags) !== 0;
        }

parseFunctionBlock:

(allowYield, allowAwait, ignoreMissingOpenBrace, diagnosticMessage) {
            var savedYieldContext = 🔷inYieldContext();
            🔷setYieldContext(allowYield);
            var savedAwaitContext = 🔷inAwaitContext();
            🔷setAwaitContext(allowAwait);
            var saveDecoratorContext = 🔷inDecoratorContext();
            if (saveDecoratorContext) {
                🔶️setDecoratorContext(false);
            }
            var block = 🔷parseBlock(ignoreMissingOpenBrace, diagnosticMessage);
            if (saveDecoratorContext) {
                🔶️setDecoratorContext(true);
            }
            🔶setYieldContext(savedYieldContext);
            🔶setAwaitContext(savedAwaitContext);
            return block;
        }
Inlined functions:
inYieldContext
() {
            return 🔷inContext(4096);
        }
Inlined functions:
inContext
(flags) {
            return (contextFlags & flags) !== 0;
        }
setYieldContext
(val) {
            🔷setContextFlag(val, 4096);
        }
Inlined functions:
setContextFlag
(val, flag) {
            if (val) {
                contextFlags |= flag;
            }
            else {
                contextFlags &= ~flag;
            }
        }
inAwaitContext
() {
            return 🔷inContext(16384);
        }
Inlined functions:
inContext
(flags) {
            return (contextFlags & flags) !== 0;
        }
setAwaitContext
(val) {
            🔷setContextFlag(val, 16384);
        }
Inlined functions:
setContextFlag
(val, flag) {
            if (val) {
                contextFlags |= flag;
            }
            else {
                contextFlags &= ~flag;
            }
        }
inDecoratorContext
() {
            return 🔷inContext(8192);
        }
Inlined functions:
inContext
(flags) {
            return (contextFlags & flags) !== 0;
        }
parseBlock
(ignoreMissingOpenBrace, diagnosticMessage) {
            var node = 🔷createNode(204);
            if (🔷parseExpected(16, diagnosticMessage) || ignoreMissingOpenBrace) {
                if (scanner.🔶hasPrecedingLineBreak()) {
                    node.multiLine = true;
                }
                node.statements = 🔶parseList(1, parseStatement);
                🔶parseExpected(17);
            }
            else {
                node.statements ⚠️= createMissingList();
            }
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

⛔ lastOrUndefined (deoptimizated):

~recompile~
~recompile~
- Deopt: <JS Function isParameterPropertyDeclaration (SharedFunctionInfo 0x30d407ff0701)> (opt #633) @23, FP to SP delta: 56, caller sp: 0x7fff5fbfdb68
~recompile~
(array) {
        return array && array⚠️.length > 0
            ? array[array.length - 1]
            : undefined;
    }

isTraceEnabled:

(compilerOptions, host) {
        return compilerOptions.traceResolution && host⚠️.trace !== undefined;
    }

moduleHasNonRelativeName:

(moduleName) {
        return !(ts.🔷isRootedDiskPath(moduleName) || ts.🔷isExternalModuleNameRelative(moduleName));
    }
Inlined functions:
isRootedDiskPath
(path) {
        return 🔶getRootLength(path) !== 0;
    }
isExternalModuleNameRelative
(moduleName) {
        return 🔶️/^\x5c.\x5c.?($|[\🔶️x5c\x5c/])/.test(moduleName);
    }

nextTokenCanFollowModifier:

() {
            if (🔷token() === 75) {
                return 🔷nextToken() === 82;
            }
            if (🔷token() === 83) {
                🔷nextToken();
                if (🔷token() === 78) {
                    return 🔷lookAhead(nextTokenIsClassOrFunctionOrAsync);
                }
                return 🔷token() !== 38 && 🔷token() !== 117 && 🔷token() !== 16 && 🔷canFollowModifier();
            }
            if (🔷token() === 78) {
                return 🔷nextTokenIsClassOrFunctionOrAsync();
            }
            if (🔷token() === 114) {
                🔷nextToken();
                return 🔷canFollowModifier();
            }
            return 🔷nextTokenIsOnSameLineAndCanFollowModifier();
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
token
() {
            return currentToken;
        }
lookAhead
(callback) {
            return 🔶speculationHelper(callback, true);
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
canFollowModifier
() {
            return 🔷token() === 20
                || 🔷token() === 16
                || 🔷token() === 38
                || 🔷token() === 23
                || 🔷isLiteralPropertyName();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isLiteralPropertyName
() {
            return ts.🔷tokenIsIdentifierOrKeyword(🔷token()) ||
                🔷token() === 9 ||
                🔷token() === 8;
        }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
nextTokenIsClassOrFunctionOrAsync
() {
            🔷nextToken();
            return 🔷token() === 74 || 🔷token() === 88 ||
                (🔷token() === 119 && 🔶lookAhead(nextTokenIsFunctionKeywordOnSameLine));
        }
Inlined functions:
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
canFollowModifier
() {
            return 🔷token() === 20
                || 🔷token() === 16
                || 🔷token() === 38
                || 🔷token() === 23
                || 🔷isLiteralPropertyName();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isLiteralPropertyName
() {
            return ts.🔷tokenIsIdentifierOrKeyword(🔷token()) ||
                🔷token() === 9 ||
                🔷token() === 8;
        }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
nextTokenIsOnSameLineAndCanFollowModifier
() {
            🔷nextToken();
            if (scanner.🔶hasPrecedingLineBreak()) {
                return false;
            }
            return 🔷canFollowModifier();
        }
Inlined functions:
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
canFollowModifier
() {
            return 🔷token() === 20
                || 🔷token() === 16
                || 🔷token() === 38
                || 🔷token() === 23
                || 🔷isLiteralPropertyName();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isLiteralPropertyName
() {
            return ts.🔷tokenIsIdentifierOrKeyword(🔷token()) ||
                🔷token() === 9 ||
                🔷token() === 8;
        }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

parseNonParameterInitializer:

() {
            return 🔷parseInitializer(false);
        }
Inlined functions:
parseInitializer
(inParameter) {
            if (🔷token() !== 57) {
                if (scanner.🔶hasPrecedingLineBreak() || (inParameter && 🔷token() === 16) || !🔶isStartOfExpression()) {
                    return undefined;
                }
            }
            🔷parseExpected(57);
            return 🔶parseAssignmentExpressionOrHigher();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

isInOrOfKeyword:

(t) {
            return t === 91 || t === 140;
        }

inDisallowInContext:

() {
            return 🔷inContext(2048);
        }
Inlined functions:
inContext
(flags) {
            return (contextFlags & flags) !== 0;
        }

parseVariableDeclaration:

() {
            var node = 🔷createNode(223);
            node.name = 🔷parseIdentifierOrPattern();
            node.type = 🔶parseTypeAnnotation();
            if (!🔶isInOrOfKeyword(🔶token())) {
                node.initializer = 🔶parseInitializer(false);
            }
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseIdentifierOrPattern
() {
            if (🔷token() === 20) {
                return 🔷parseArrayBindingPattern();
            }
            if (🔶token() === 16) {
                return 🔶️parseObjectBindingPattern();
            }
            return 🔶parseIdentifier();
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseArrayBindingPattern
() {
            var node = 🔷createNode(173);
            🔶parseExpected(20);
            node.elements ⚠️= parseDelimitedList(10, parseArrayBindingElement);
            🔶parseExpected(21);
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

parseTypeArgumentsInExpression:

() {
            if (!🔷parseOptional(26)) {
                return undefined;
            }
            var typeArguments = 🔶parseDelimitedList(19, parseType);
            if (!🔷parseExpected(28)) {
                return undefined;
            }
            return typeArguments && 🔶️canFollowTypeArgumentsInExpression()
                ? typeArguments
                : undefined;
        }
Inlined functions:
parseOptional
(t) {
            if (🔷token() === t) {
                🔷nextToken();
                return true;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

⛔ toKey (deoptimizated):

~recompile~
- Deopt: <JS Function hasModifier (SharedFunctionInfo 0x30d407fe66a1)> (opt #222) @19, FP to SP delta: 48, caller sp: 0x7fff5fbfda50
~recompile~
(path) {
            return keyMapper ? 🔷keyMapper(path) : path;
        }
Inlined functions:
keyMapper
(key) { return key.🔶️toLocaleLowerCase(); }

reScanJsxToken:

() {
            pos = tokenPos = startPos;
            return token = 🔶scanJsxToken();
        }

loadModuleFromNodeModulesFolder:

~recompile~
~recompile~
(extensions, moduleName, directory, failedLookupLocations, state) {
        var nodeModulesFolder = ts.🔷combinePaths(directory, "node_modules");
        var nodeModulesFolderExists = 🔷directoryProbablyExists(nodeModulesFolder, state.host);
        var candidate = ts.🔷normalizePath(ts.🔷combinePaths(nodeModulesFolder, moduleName));
        return 🔶loadModuleFromFile(extensions, candidate, failedLookupLocations, !nodeModulesFolderExists, state) ||
            🔶loadNodeModuleFromDirectory(extensions, candidate, failedLookupLocations, !nodeModulesFolderExists, state);
    }
Inlined functions:
combinePaths
(path1, path2) {
        if (!(path1 && path1.length))
            return path2;
        if (!(path2 && path2⚠️.length))
            return path1;
        if (🔶getRootLength(path2) !== 0)
            return path2;
        if (path1.charAt(path1.length - 1) === ts.directorySeparator)
            return path1 + path2;
        return path1 + ts.directorySeparator + path2;
    }
directoryProbablyExists
(directoryName, host) {
        return !host.directoryExists || host.🔶directoryExists(directoryName);
    }
combinePaths
(path1, path2) {
        if (!(path1 && path1.length))
            return path2;
        if (!(path2 && path2⚠️.length))
            return path1;
        if (🔶getRootLength(path2) !== 0)
            return path2;
        if (path1.charAt(path1.length - 1) === ts.directorySeparator)
            return path1 + path2;
        return path1 + ts.directorySeparator + path2;
    }
normalizePath
(path) {
        path = 🔷normalizeSlashes(path);
        var rootLength = 🔶getRootLength(path);
        var root = path.🔶substr(0, rootLength);
        var normalized = 🔶getNormalizedParts(path, rootLength);
        if (normalized.length) {
            var joinedParts = root + normalized.🔶join(ts.directorySeparator);
            return 🔷pathEndsWithDirectorySeparator(path) ? joinedParts ⚠️+ ts⚠️.directorySeparator : joinedParts;
        }
        else {
            return root;
        }
    }
Inlined functions:
normalizeSlashes
(path) {
        return path.⚠️replace(🔶️/\x5c\x5c/g, "/");
    }
pathEndsWithDirectorySeparator
(path) {
        return path.charCodeAt(path.length - 1) === directorySeparatorCharCode;
    }

parseJsxChild:

() {
            switch (🔷token()) {
                case 10:
                    return 🔷parseJsxText();
                case 16:
                    return 🔷parseJsxExpression(false);
                case 26:
                    return 🔶️parseJsxElementOrSelfClosingElement(false);
            }
            ts⚠️.Debug.🔶️fail("Unknown JSX child kind " + 🔶token());
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseJsxText
() {
            var node = 🔷createNode(10, scanner.🔶getStartPos());
            currentToken = scanner.🔶scanJsxToken();
            return 🔷finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }
parseJsxExpression
(inExpressionContext) {
            var node = 🔷createNode(252);
            🔶parseExpected(16);
            if (🔶token() !== 17) {
                node.expression = 🔶parseAssignmentExpressionOrHigher();
            }
            if (inExpressionContext) {
                🔶parseExpected(17);
            }
            else {
                🔶parseExpected(17, undefined, false);
                🔶scanJsxText();
            }
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

getExternalModuleName:

~recompile~
~recompile~
~recompile~
~recompile~
(node) {
        if (node⚠️.kind === 235) {
            return node.moduleSpecifier;
        }
        if (node.kind === 234) {
            var reference = node.moduleReference;
            if (reference.kind === 245) {
                return reference.expression;
            }
        }
        if (node.kind === 241) {
            return node.moduleSpecifier;
        }
        if (node⚠️.kind ⚠️=== 230 && node⚠️.name⚠️.kind ⚠️=== 9) {
            return node⚠️.name;
        }
    }

tryAddingExtensions:

~recompile~
~recompile~
(candidate, extensions, failedLookupLocations, onlyRecordFailures, state) {
        if (!onlyRecordFailures) {
            var directory = ts.🔷getDirectoryPath(candidate);
            if (directory) {
                onlyRecordFailures = !🔷directoryProbablyExists(directory, state.host);
            }
        }
        switch (extensions) {
            case 2:
                return 🔶tryExtension(".d.ts", ts.Extension.Dts);
            case 0:
                return 🔶tryExtension(".ts", ts.Extension.Ts) || 🔶tryExtension(".tsx", ts.Extension.Tsx) || 🔶tryExtension(".d.ts", ts.Extension.Dts);
            case 1:
                return 🔶tryExtension(".js", ts.Extension.Js) || 🔶tryExtension(".jsx", ts.Extension.Jsx);
        }
        🔶️function tryExtension(ext, extension) {
            var path = tryFile(candidate + ext, failedLookupLocations, onlyRecordFailures, state);
            return path && { path: path, extension: extension };
        }
    }
Inlined functions:
getDirectoryPath
(path) {
        return path.🔶substr(0, Math.max(🔶getRootLength(path), path.🔶lastIndexOf(ts.directorySeparator)));
    }
directoryProbablyExists
(directoryName, host) {
        return !host.directoryExists || host.🔶directoryExists(directoryName);
    }

getNormalizedParts:

(normalizedSlashedPath, rootLength) {
        var parts = normalizedSlashedPath.🔶substr(rootLength).split(ts.directorySeparator);
        var normalized = [];
        for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
            var part = parts_1[_i];
            if (part !== ".") {
                if (part === ".." && normalized.length > 0 && 🔷lastOrUndefined(normalized) !== "..") {
                    normalized.pop();
                }
                else {
                    if (part) {
                        normalized.push(part);
                    }
                }
            }
        }
        return normalized;
    }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

parseNamedImportsOrExports:

(kind) {
            var node = 🔷createNode(kind);
            node.elements = 🔷parseBracketedList(22, kind === 238 ? parseImportSpecifier : parseExportSpecifier, 16, 17);
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseBracketedList
(kind, parseElement, open, close) {
            if (🔷parseExpected(open)) {
                var result = 🔶parseDelimitedList(kind, parseElement);
                🔷parseExpected(close);
                return result;
            }
            return 🔶️createMissingList();
        }
Inlined functions:
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

parseDelimitedList:

~recompile~
~recompile~
~recompile~
(kind, parseElement, considerSemicolonAsDelimiter) {
            var saveParsingContext = parsingContext;
            parsingContext |= 1 << kind;
            var result = 🔷createNodeArray();
            var commaStart = -1;
            while (true) {
                if (🔶isListElement(kind, false)) {
                    result.push(🔷parseListElement(kind, parseElement));
                    commaStart = scanner.🔶getTokenPos();
                    if (🔷parseOptional(25)) {
                        continue;
                    }
                    commaStart = -1;
                    if (🔶isListTerminator(kind)) {
                        break;
                    }
                    🔷parseExpected(25);
                    if (considerSemicolonAsDelimiter && 🔶token() ⚠️=== 24 && !scanner.🔶hasPrecedingLineBreak()) {
                        🔶nextToken();
                    }
                    continue;
                }
                if (🔶isListTerminator(kind)) {
                    break;
                }
                if (🔷abortParsingListOrMoveToNextToken(kind)) {
                    break;
                }
            }
            if (commaStart >= 0) {
                result.hasTrailingComma = true;
            }
            result.end = 🔷getNodeEnd();
            parsingContext = saveParsingContext;
            return result;
        }
Inlined functions:
createNodeArray
(elements, pos) {
            var array = (elements || []);
            if (!(pos >= 0)) {
                pos = 🔷getNodePos();
            }
            array.pos ⚠️= pos;
            array.end = pos;
            return array;
        }
Inlined functions:
getNodePos
() {
            return scanner.🔶getStartPos();
        }
parseListElement
(parsingContext, parseElement) {
            var node = 🔶currentNode(parsingContext);
            if (node) {
                return 🔶️consumeNode(node);
            }
            return 🔶️parseElement();
        }
parseOptional
(t) {
            if (🔷token() === t) {
                🔷nextToken();
                return true;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
abortParsingListOrMoveToNextToken
(kind) {
            🔷parseErrorAtCurrentToken(🔶️parsingContextErrors(kind));
            if (🔷isInSomeParsingContext()) {
                return true;
            }
            🔷nextToken();
            return false;
        }
Inlined functions:
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
isInSomeParsingContext
() {
            for (var kind = 0; kind < 27; kind++) {
                if (parsingContext & (1 << kind)) {
                    if (🔶isListElement(kind, true) || 🔶isListTerminator(kind)) {
                        return true;
                    }
                }
            }
            return false;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
getNodeEnd
() {
            return scanner.🔶getStartPos();
        }

parseModuleSpecifier:

() {
            if (🔷token() === 9) {
                var result = 🔷parseLiteralNode();
                🔷internIdentifier(result.text);
                return result;
            }
            else {
                return 🔶️parseExpression();
            }
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseLiteralNode
(internName) {
            return 🔶parseLiteralLikeNode(🔷token(), internName);
        }
Inlined functions:
token
() {
            return currentToken;
        }
internIdentifier
(text) {
            text = ts.🔷escapeIdentifier(text);
            return identifiers⚠️[text] || (identifiers[text] ⚠️= text);
        }
Inlined functions:
escapeIdentifier
(identifier) {
        return identifier⚠️.length >= 2 && identifier.🔶️charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 ? "_" + identifier : identifier;
    }

parseImportClause:

(identifier, fullStart) {
            var importClause = 🔷createNode(236, fullStart);
            if (identifier) {
                importClause.name = identifier;
            }
            if (!importClause.name ||
                🔷parseOptional(25)) {
                importClause.namedBindings = 🔷token() === 38 ? 🔷parseNamespaceImport() : 🔶parseNamedImportsOrExports(238);
            }
            return 🔶finishNode(importClause);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseOptional
(t) {
            if (🔷token() === t) {
                🔷nextToken();
                return true;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
token
() {
            return currentToken;
        }
parseNamespaceImport
() {
            var namespaceImport = 🔷createNode(237);
            🔶parseExpected(38);
            🔶parseExpected(117);
            namespaceImport.name = 🔶parseIdentifier();
            return 🔶finishNode(namespaceImport);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

parseImportSpecifier:

() {
            return 🔶️parseImportOrExportSpecifier(239);
        }

parseList:

~recompile~
~recompile~
(kind, parseElement) {
            var saveParsingContext = parsingContext;
            parsingContext |= 1 << kind;
            var result = 🔷createNodeArray();
            while (!🔶isListTerminator(kind)) {
                if (🔶isListElement(kind, false)) {
                    var element = 🔷parseListElement(kind, parseElement);
                    result.push(element);
                    continue;
                }
                if (🔶️abortParsingListOrMoveToNextToken(kind)) {
                    break;
                }
            }
            result.end = 🔷getNodeEnd();
            parsingContext = saveParsingContext;
            return result;
        }
Inlined functions:
createNodeArray
(elements, pos) {
            var array = (elements || []);
            if (!(pos >= 0)) {
                pos = 🔷getNodePos();
            }
            array.pos ⚠️= pos;
            array.end = pos;
            return array;
        }
Inlined functions:
getNodePos
() {
            return scanner.🔶getStartPos();
        }
parseListElement
(parsingContext, parseElement) {
            var node = 🔶currentNode(parsingContext);
            if (node) {
                return 🔶️consumeNode(node);
            }
            return 🔶️parseElement();
        }
getNodeEnd
() {
            return scanner.🔶getStartPos();
        }

parseJsxAttribute:

() {
            if (🔷token() === 16) {
                return 🔶️parseJsxSpreadAttribute();
            }
            🔷scanJsxIdentifier();
            var node = 🔷createNode(250);
            node.name = 🔷parseIdentifierName();
            if (🔶token() === 57) {
                switch (🔶scanJsxAttributeValue()) {
                    case 9:
                        node.initializer = 🔶parseLiteralNode();
                        break;
                    default:
                        node.initializer = 🔶parseJsxExpression(true);
                        break;
                }
            }
            return 🔶finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
scanJsxIdentifier
() {
            return currentToken = scanner.🔶scanJsxIdentifier();
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseIdentifierName
() {
            return 🔷createIdentifier(ts.🔷tokenIsIdentifierOrKeyword(🔷token()));
        }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
createIdentifier
(isIdentifier, diagnosticMessage) {
            identifierCount++;
            if (isIdentifier) {
                var node = 🔷createNode(70);
                if (🔶token() !== 70) {
                    node.originalKeywordKind = 🔶token();
                }
                node.text = 🔶️internIdentifier(scanner.🔶getTokenValue());
                🔶nextToken();
                return 🔶finishNode(node);
            }
            return 🔶️createMissingNode(70, false, diagnosticMessage || ts⚠️.Diagnostics⚠️.Identifier_expected);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

scanJsxAttributeValue:

~recompile~
~recompile~
() {
            startPos = pos;
            switch (text.charCodeAt(pos)) {
                case 34:
                case 39:
                    tokenValue = 🔶scanString(false);
                    return token = 9;
                default:
                    return 🔶scan();
            }
        }

scanJsxText:

() {
            return currentToken = scanner.🔶scanJsxToken();
        }

getTextOfLiteral:

(literal) {
            return literal.text;
        }

loader_1:

~recompile~
~recompile~
(moduleName, containingFile) { return ts.🔶resolveModuleName(moduleName, containingFile, options, host).resolvedModule; }

getEmitModuleKind:

(compilerOptions) {
        return typeof compilerOptions.module === "number" ?
            compilerOptions.module :
            🔶getEmitScriptTarget(compilerOptions) ⚠️>= 2 ? ts⚠️.ModuleKind⚠️.ES2015 : ts⚠️.ModuleKind⚠️.CommonJS;
    }

tryLoadModuleUsingOptionalResolutionSettings:

(extensions, moduleName, containingDirectory, loader, failedLookupLocations, state) {
        if (🔷moduleHasNonRelativeName(moduleName)) {
            return 🔶️tryLoadModuleUsingBaseUrl(extensions, moduleName, loader, failedLookupLocations, state);
        }
        else {
            return 🔶️tryLoadModuleUsingRootDirs(extensions, moduleName, containingDirectory, loader, failedLookupLocations, state);
        }
    }
Inlined functions:
moduleHasNonRelativeName
(moduleName) {
        return !(ts.🔷isRootedDiskPath(moduleName) || ts.🔷isExternalModuleNameRelative(moduleName));
    }
Inlined functions:
isRootedDiskPath
(path) {
        return 🔶getRootLength(path) !== 0;
    }
isExternalModuleNameRelative
(moduleName) {
        return 🔶️/^\x5c.\x5c.?($|[\🔶️x5c\x5c/])/.test(moduleName);
    }

createResolvedModuleWithFailedLookupLocations:

~recompile~
~recompile~
(resolved, isExternalLibraryImport, failedLookupLocations) {
        return { resolvedModule: resolved && 🔷resolvedModuleFromResolved(resolved, isExternalLibraryImport), failedLookupLocations: failedLookupLocations };
    }
Inlined functions:
resolvedModuleFromResolved
(_a, isExternalLibraryImport) {
        var path = _a.path, extension = _a.extension;
        return { resolvedFileName: path, extension: extension, isExternalLibraryImport: isExternalLibraryImport };
    }

fileExists:

~recompile~
~recompile~
(path) {
                return 🔶️fileSystemEntryExists(path, 0);
            }

getBaseFileName:

(path) {
        if (path === undefined) {
            return undefined;
        }
        var i = path.🔶lastIndexOf(ts.directorySeparator);
        return i < 0 ? path : path.🔶substring(i + 1);
    }

currentNode:

(parsingContext) {
            if (parseErrorBeforeNextFinishedNode) {
                return undefined;
            }
            if (!syntaxCursor) {
                return undefined;
            }
            var node = syntaxCursor.🔶currentNode(scanner.⚠️getStartPos());
            if (ts.🔶nodeIsMissing(node)) {
                return undefined;
            }
            if (node⚠️.intersectsChange) {
                return undefined;
            }
            if (ts.🔶️containsParseError(node)) {
                return undefined;
            }
            var nodeContextFlags = node⚠️.flags ⚠️& 96256;
            if (nodeContextFlags ⚠️!== contextFlags) {
                return undefined;
            }
            if (!🔶️canReuseNode(node, parsingContext)) {
                return undefined;
            }
            return node;
        }

isDeclaration:

() {
            while (true) {
                ⚠️switch (🔷token()) {
                    case 103:
                    case 109:
                    case 75:
                    case 88:
                    case 74:
                    case 82:
                        return true;
                    case 108:
                    case 136:
                        return 🔷nextTokenIsIdentifierOnSameLine();
                    case 127:
                    case 128:
                        return 🔷nextTokenIsIdentifierOrStringLiteralOnSameLine();
                    case 116:
                    case 119:
                    case 123:
                    case 111:
                    case 112:
                    case 113:
                    case 130:
                        🔷nextToken();
                        if (scanner.🔶hasPrecedingLineBreak()) {
                            return false;
                        }
                        continue;
                    case 139:
                        🔷nextToken();
                        return 🔷token() === 16 || 🔷token() === 70 || 🔷token() === 83;
                    case 90:
                        🔷nextToken();
                        return 🔷token() === 9 || 🔷token() === 38 ||
                            🔷token() === 16 || ts.🔷tokenIsIdentifierOrKeyword(🔷token());
                    case 83:
                        🔷nextToken();
                        if (🔷token() === 57 || 🔷token() === 38 ||
                            🔷token() === 16 || 🔷token() === 78 ||
                            🔷token() === 117) {
                            return true;
                        }
                        continue;
                    case 114:
                        🔶nextToken();
                        continue;
                    default:
                        return false;
                }
            }
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextTokenIsIdentifierOnSameLine
() {
            🔷nextToken();
            return !scanner.🔶hasPrecedingLineBreak() && 🔷isIdentifier();
        }
Inlined functions:
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
nextTokenIsIdentifierOrStringLiteralOnSameLine
() {
            🔷nextToken();
            return !scanner.🔶hasPrecedingLineBreak() && (🔷isIdentifier() || 🔷token() === 9);
        }
Inlined functions:
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

parseClassElement:

() {
            if (🔷token() === 24) {
                var result = 🔶createNode(203);
                🔶nextToken();
                return 🔶finishNode(result);
            }
            var fullStart = 🔷getNodePos();
            var decorators = parseDecorators();
            var modifiers = parseModifiers(true);
            var accessor = 🔷tryParseAccessorDeclaration(fullStart, decorators, modifiers);
            if (accessor) {
                return accessor;
            }
            if (🔶token() === 122) {
                return 🔶️parseConstructorDeclaration(fullStart, decorators, modifiers);
            }
            if (🔶isIndexSignature()) {
                return 🔶️parseIndexSignatureDeclaration(fullStart, decorators, modifiers);
            }
            if (ts.🔶tokenIsIdentifierOrKeyword(🔶token()) ||
                🔶token() === 9 ||
                🔶token() === 8 ||
                🔶token() === 38 ||
                🔶token() === 20) {
                return 🔶parsePropertyOrMethodDeclaration(fullStart, decorators, modifiers);
            }
            if (decorators || modifiers) {
                var name_13 = 🔶️createMissingNode(70, true, ts⚠️.Diagnostics⚠️.Declaration_expected);
                return 🔶parsePropertyDeclaration(fullStart, decorators, modifiers, name_13, undefined);
            }
            ts⚠️.Debug.⚠️fail("Should not have attempted to parse class member declaration.");
        }
Inlined functions:
token
() {
            return currentToken;
        }
getNodePos
() {
            return scanner.getStartPos();
        }
tryParseAccessorDeclaration
(fullStart, decorators, modifiers) {
            if (🔷parseContextualModifier(124)) {
                return 🔷parseAccessorDeclaration(151, fullStart, decorators, modifiers);
            }
            else if (🔶parseContextualModifier(133)) {
                return 🔶️parseAccessorDeclaration(152, fullStart, decorators, modifiers);
            }
            return undefined;
        }
Inlined functions:
parseContextualModifier
(t) {
            return 🔷token() === t && 🔷tryParse(nextTokenCanFollowModifier);
        }
Inlined functions:
token
() {
            return currentToken;
        }
tryParse
(callback) {
            return 🔶speculationHelper(callback, false);
        }
parseAccessorDeclaration
(kind, fullStart, decorators, modifiers) {
            var node = 🔷createNode(kind, fullStart);
            node.decorators = decorators;
            node.modifiers = modifiers;
            node.name = 🔷parsePropertyName();
            🔶fillSignature(55, false, false, false, node);
            node.body = 🔷parseFunctionBlockOrSemicolon(false, false);
            return 🔶addJSDocComment(🔶finishNode(node));
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parsePropertyName
() {
            return 🔷parsePropertyNameWorker(true);
        }
Inlined functions:
parsePropertyNameWorker
(allowComputedPropertyNames) {
            if (🔷token() === 9 || 🔷token() === 8) {
                return 🔷parseLiteralNode(true);
            }
            if (allowComputedPropertyNames && 🔷token() === 20) {
                return 🔷parseComputedPropertyName();
            }
            return 🔷parseIdentifierName();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseLiteralNode
(internName) {
            return 🔶parseLiteralLikeNode(🔶token(), internName);
        }
token
() {
            return currentToken;
        }
parseComputedPropertyName
() {
            var node = 🔶createNode(142);
            🔶parseExpected(20);
            node.expression = 🔶allowInAnd(parseExpression);
            🔶parseExpected(21);
            return 🔶finishNode(node);
        }
parseIdentifierName
() {
            return 🔶createIdentifier(ts.🔶tokenIsIdentifierOrKeyword(🔶token()));
        }
parseFunctionBlockOrSemicolon
(isGenerator, isAsync, diagnosticMessage) {
            if (🔷token() !== 16 && 🔷canParseSemicolon()) {
                🔷parseSemicolon();
                return;
            }
            return 🔶parseFunctionBlock(isGenerator, isAsync, false, diagnosticMessage);
        }
Inlined functions:
token
() {
            return currentToken;
        }
canParseSemicolon
() {
            if (🔷token() === 24) {
                return true;
            }
            return 🔷token() === 17 || 🔷token() === 1 || scanner.🔶hasPrecedingLineBreak();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseSemicolon
() {
            if (🔷canParseSemicolon()) {
                if (🔷token() === 24) {
                    🔷nextToken();
                }
                return true;
            }
            else {
                return 🔶parseExpected(24);
            }
        }
Inlined functions:
canParseSemicolon
() {
            if (🔶token() === 24) {
                return true;
            }
            return 🔶token() === 17 || 🔶token() === 1 || scanner.🔶hasPrecedingLineBreak();
        }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }

nodeLoadModuleByRelativeName:

(extensions, candidate, failedLookupLocations, onlyRecordFailures, state) {
        if (state.traceEnabled) {
            🔶️trace(state⚠️.host, ts⚠️.Diagnostics⚠️.Loading_module_as_file_Slash_folder_candidate_module_location_0, candidate);
        }
        var resolvedFromFile = !ts.🔷pathEndsWithDirectorySeparator(candidate) && 🔶loadModuleFromFile(extensions, candidate, failedLookupLocations, onlyRecordFailures, state);
        return resolvedFromFile || 🔶loadNodeModuleFromDirectory(extensions, candidate, failedLookupLocations, onlyRecordFailures, state);
    }
Inlined functions:
pathEndsWithDirectorySeparator
(path) {
        return path.charCodeAt(path.length - 1) === directorySeparatorCharCode;
    }

pathToPackageJson:

(directory) {
        return ts.🔷combinePaths(directory, "package.json");
    }
Inlined functions:
combinePaths
(path1, path2) {
        if (!(path1 && path1.length))
            return path2;
        if (!(path2 && path2.length))
            return path1;
        if (🔶getRootLength(path2) !== 0)
            return path2;
        if (path1.charAt(path1.length - 1) === ts.directorySeparator)
            return path1 ⚠️+ path2;
        return path1 + ts.directorySeparator + path2;
    }

getCanonicalFileName:

~recompile~
~recompile~
(fileName) {
            return host.🔶getCanonicalFileName(fileName);
        }

toPath:

(fileName, basePath, getCanonicalFileName) {
        var nonCanonicalizedPath = 🔷isRootedDiskPath(fileName)
            ? 🔷normalizePath(fileName)
            : 🔶getNormalizedAbsolutePath(fileName, basePath);
        return 🔶getCanonicalFileName(nonCanonicalizedPath);
    }
Inlined functions:
isRootedDiskPath
(path) {
        return 🔶getRootLength(path) !== 0;
    }
normalizePath
(path) {
        path = 🔷normalizeSlashes(path);
        var rootLength = 🔶getRootLength(path);
        var root = path.🔶substr(0, rootLength);
        var normalized = 🔶getNormalizedParts(path, rootLength);
        if (normalized.length) {
            var joinedParts = root + normalized.🔶join(ts.directorySeparator);
            return 🔷pathEndsWithDirectorySeparator(path) ? joinedParts ⚠️+ ts⚠️.directorySeparator : joinedParts;
        }
        else {
            return root;
        }
    }
Inlined functions:
normalizeSlashes
(path) {
        return path.⚠️replace(🔶️/\x5c\x5c/g, "/");
    }
pathEndsWithDirectorySeparator
(path) {
        return path.charCodeAt(path.length - 1) === directorySeparatorCharCode;
    }

contains:

(path) {
            return 🔷toKey(path) 🔶️in files;
        }
Inlined functions:
toKey
(path) {
            return keyMapper ? 🔶️keyMapper(path) : path;
        }

setResolvedModule:

(sourceFile, moduleNameText, resolvedModule) {
        if (!sourceFile.resolvedModules) {
            sourceFile.resolvedModules ⚠️= ts.🔶createMap();
        }
        sourceFile.resolvedModules[moduleNameText] ⚠️= resolvedModule;
    }

⛔ positionIsSynthesized (deoptimizated):

(pos) {
        return !(pos >= 0);
    }
- Deopt: <JS Function parseIncrementExpression (SharedFunctionInfo 0x98bdb9ce879)> (opt #209) @3, FP to SP delta: 168, caller sp: 0x7fff5fbfce08
- Deopt: <JS Function combinePaths (SharedFunctionInfo 0x30d407fbc2a1)> (opt #3) @16, FP to SP delta: 40, caller sp: 0x7fff5fbfd628
- Deopt: <JS Function getRootLength (SharedFunctionInfo 0x30d407fbb2e1)> (opt #10) @14, FP to SP delta: 24, caller sp: 0x7fff5fbfd628

parseJsxExpression:

(inExpressionContext) {
            var node = 🔷createNode(252);
            🔷parseExpected(16);
            if (🔷token() !== 17) {
                node.expression = 🔶parseAssignmentExpressionOrHigher();
            }
            if (inExpressionContext) {
                🔷parseExpected(17);
            }
            else {
                🔶parseExpected(17, undefined, false);
                🔶scanJsxText();
            }
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
token
() {
            return currentToken;
        }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

parseReturnStatement:

() {
            var node = 🔷createNode(216);
            🔷parseExpected(95);
            if (!🔷canParseSemicolon()) {
                node.expression = 🔷allowInAnd(parseExpression);
            }
            🔶parseSemicolon();
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
canParseSemicolon
() {
            if (🔷token() === 24) {
                return true;
            }
            return 🔷token() === 17 || 🔷token() === 1 || scanner.🔶hasPrecedingLineBreak();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
allowInAnd
(func) {
            return 🔷doOutsideOfContext(2048, func);
        }
Inlined functions:
doOutsideOfContext
(context, func) {
            var contextFlagsToClear = context & contextFlags;
            if (contextFlagsToClear) {
                🔶setContextFlag(false, contextFlagsToClear);
                var result = 🔶️func();
                🔶setContextFlag(true, contextFlagsToClear);
                return result;
            }
            return 🔶️func();
        }

loadNodeModuleFromDirectory:

(extensions, candidate, failedLookupLocations, onlyRecordFailures, state) {
        var packageJsonPath = 🔷pathToPackageJson(candidate);
        var directoryExists = !onlyRecordFailures && 🔷directoryProbablyExists(candidate, state.host);
        if (directoryExists && state.host.🔶fileExists(packageJsonPath)) {
            if (state.traceEnabled) {
                🔶️trace(state⚠️.host, ts⚠️.Diagnostics⚠️.Found_package_json_at_0, packageJsonPath);
            }
            var typesFile = tryReadTypesSection(extensions, packageJsonPath, candidate, state);
            if (typesFile) {
                var onlyRecordFailures_1 = !🔷directoryProbablyExists(ts.🔷getDirectoryPath(typesFile), state.host);
                var fromFile = 🔷tryFile(typesFile, failedLookupLocations, onlyRecordFailures_1, state);
                if (fromFile) {
                    return 🔷resolvedFromAnyFile(fromFile);
                }
                var x = 🔶tryAddingExtensions(typesFile, 0, failedLookupLocations, onlyRecordFailures_1, state);
                if (x) {
                    return x;
                }
            }
            else {
                if (state.traceEnabled) {
                    🔶️trace(state⚠️.host, ts⚠️.Diagnostics⚠️.package_json_does_not_have_a_types_or_main_field);
                }
            }
        }
        else {
            if (state.traceEnabled) {
                🔶️trace(state⚠️.host, ts⚠️.Diagnostics⚠️.File_0_does_not_exist, packageJsonPath);
            }
            failedLookupLocations.push(packageJsonPath);
        }
        return 🔶loadModuleFromFile(extensions, ts.🔷combinePaths(candidate, "index"), failedLookupLocations, !directoryExists, state);
    }
Inlined functions:
pathToPackageJson
(directory) {
        return ts.🔷combinePaths(directory, "package.json");
    }
Inlined functions:
combinePaths
(path1, path2) {
        if (!(path1 && path1.length))
            return path2;
        if (!(path2 && path2⚠️.length))
            return path1;
        if (🔶getRootLength(path2) !== 0)
            return path2;
        if (path1.charAt(path1.length - 1) === ts.directorySeparator)
            return path1 + path2;
        return path1 + ts.directorySeparator + path2;
    }
directoryProbablyExists
(directoryName, host) {
        return !host.directoryExists || host.🔶directoryExists(directoryName);
    }
getDirectoryPath
(path) {
        return path.🔶substr(0, Math.max(🔶getRootLength(path), path.🔶lastIndexOf(ts.directorySeparator)));
    }
directoryProbablyExists
(directoryName, host) {
        return !host.directoryExists || host.🔶directoryExists(directoryName);
    }
tryFile
(fileName, failedLookupLocations, onlyRecordFailures, state) {
        if (!onlyRecordFailures && state.host.🔶fileExists(fileName)) {
            if (state.traceEnabled) {
                🔶️trace(state⚠️.host, ts⚠️.Diagnostics⚠️.File_0_exist_use_it_as_a_name_resolution_result, fileName);
            }
            return fileName;
        }
        else {
            if (state.traceEnabled) {
                🔶️trace(state⚠️.host, ts⚠️.Diagnostics⚠️.File_0_does_not_exist, fileName);
            }
            failedLookupLocations.push(fileName);
            return undefined;
        }
    }
resolvedFromAnyFile
(path) {
        return { path: path, extension: ts.🔷extensionFromPath(path) };
    }
Inlined functions:
extensionFromPath
(path) {
        var ext = 🔷tryGetExtensionFromPath(path);
        if (ext !== undefined) {
            return ext;
        }
        Debug.🔶️fail("File " + path + " has unknown extension.");
    }
Inlined functions:
tryGetExtensionFromPath
(path) {
        if (🔷fileExtensionIs(path, ".d.ts")) {
            return ts.Extension.Dts;
        }
        if (🔶fileExtensionIs(path, ".ts")) {
            return ts⚠️.Extension⚠️.Ts;
        }
        if (🔶fileExtensionIs(path, ".tsx")) {
            return ts⚠️.Extension⚠️.Tsx;
        }
        if (🔶fileExtensionIs(path, ".js")) {
            return ts⚠️.Extension⚠️.Js;
        }
        if (🔶fileExtensionIs(path, ".jsx")) {
            return ts⚠️.Extension⚠️.Jsx;
        }
    }
Inlined functions:
fileExtensionIs
(path, extension) {
        return path.length > extension.length && 🔷endsWith(path, extension);
    }
Inlined functions:
endsWith
(str, suffix) {
        var expectedPos = str.length - suffix.length;
        return expectedPos >= 0 && str.🔶indexOf(suffix, expectedPos) === expectedPos;
    }
combinePaths
(path1, path2) {
        if (!(path1 && path1.length))
            return path2;
        if (!(path2 && path2⚠️.length))
            return path1;
        if (🔶getRootLength(path2) !== 0)
            return path2;
        if (path1.charAt(path1.length - 1) === ts.directorySeparator)
            return path1 + path2;
        return path1 + ts.directorySeparator + path2;
    }

parseBinaryExpressionRest:

(precedence, leftOperand) {
            while (true) {
                🔷reScanGreaterToken();
                var newPrecedence = 🔶getBinaryOperatorPrecedence();
                var consumeCurrentOperator = 🔷token() === 39 ?
                    newPrecedence ⚠️>= precedence :
                    newPrecedence > precedence;
                if (!consumeCurrentOperator) {
                    break;
                }
                if (🔷token() === 91 && 🔷inDisallowInContext()) {
                    break;
                }
                if (🔷token() === 117) {
                    if (scanner.🔶hasPrecedingLineBreak()) {
                        break;
                    }
                    else {
                        🔷nextToken();
                        leftOperand = 🔷makeAsExpression(leftOperand, 🔷parseType());
                    }
                }
                else {
                    leftOperand = 🔶makeBinaryExpression(leftOperand, 🔷parseTokenNode(), 🔶parseBinaryExpressionOrHigher(newPrecedence));
                }
            }
            return leftOperand;
        }
Inlined functions:
reScanGreaterToken
() {
            return currentToken = scanner.🔶reScanGreaterToken();
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
inDisallowInContext
() {
            return 🔷inContext(2048);
        }
Inlined functions:
inContext
(flags) {
            return (contextFlags & flags) !== 0;
        }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
parseType
() {
            return 🔷doOutsideOfContext(20480, parseTypeWorker);
        }
Inlined functions:
doOutsideOfContext
(context, func) {
            var contextFlagsToClear = context & contextFlags;
            if (contextFlagsToClear) {
                🔶setContextFlag(false, contextFlagsToClear);
                var result = 🔶️func();
                🔶setContextFlag(true, contextFlagsToClear);
                return result;
            }
            return 🔶️func();
        }
makeAsExpression
(left, right) {
            var node = 🔷createNode(200, left⚠️.pos);
            node.expression = left;
            node.type = right;
            return 🔷finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔶nextToken();
            return 🔶finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔶️new IdentifierConstructor(kind, pos, pos) :
                    🔶️new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

⛔ scanJsxToken (deoptimizated):

() {
            startPos = tokenPos = pos;
            if (pos >= end) {
                return token = 1;
            }
            var char = text.charCodeAt(pos);
            if (char === 60) {
                if (text.charCodeAt(pos + 1) === 47) {
                    pos += 2;
                    return token = 27;
                }
                pos++;
                return token = 26;
            }
            if (char === 123) {
                pos++;
                return token = 16;
            }
            while (pos < end) {
                pos++;
                char = text.charCodeAt(pos);
                if ((char === 123) || (char === 60)) {
                    break;
                }
            }
            return token = 10;
        }
- Deopt: <JS Function parseTokenNode (SharedFunctionInfo 0x98bdb9c7df9)> (opt #239) @32, FP to SP delta: 64, caller sp: 0x7fff5fbfbae8

parseExpectedToken:

(t, reportAtCurrentPosition, diagnosticMessage, arg0) {
            return 🔷parseOptionalToken(t) ||
                🔶️createMissingNode(t, reportAtCurrentPosition, diagnosticMessage, arg0);
        }
Inlined functions:
parseOptionalToken
(t) {
            if (🔷token() === t) {
                return 🔷parseTokenNode();
            }
            return undefined;
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔷nextToken();
            return 🔷finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags |= 32768;
            }
            return node;
        }

parseModifiers:

~recompile~
~recompile~
~recompile~
(permitInvalidConstAsModifier) {
            var modifiers;
            while (true) {
                var modifierStart = scanner.getStartPos();
                var modifierKind = 🔷token();
                if (🔷token() === 75 && permitInvalidConstAsModifier) {
                    if (!🔶tryParse(nextTokenIsOnSameLineAndCanFollowModifier)) {
                        break;
                    }
                }
                else {
                    if (!🔷parseAnyContextualModifier()) {
                        break;
                    }
                }
                var modifier = 🔷finishNode(🔷createNode(modifierKind, modifierStart));
                if (!modifiers) {
                    modifiers = 🔷createNodeArray([modifier], modifierStart);
                }
                else {
                    modifiers.push(modifier);
                }
            }
            if (modifiers) {
                modifiers.end = scanner.🔶getStartPos();
            }
            return modifiers;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseAnyContextualModifier
() {
            return ts.🔷isModifierKind(🔷token()) && 🔷tryParse(nextTokenCanFollowModifier);
        }
Inlined functions:
token
() {
            return currentToken;
        }
isModifierKind
(token) {
        switch (token) {
            case 116:
            case 119:
            case 75:
            case 123:
            case 78:
            case 83:
            case 113:
            case 111:
            case 112:
            case 130:
            case 114:
                return true;
        }
        return false;
    }
tryParse
(callback) {
            return 🔶speculationHelper(callback, false);
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }
createNodeArray
(elements, pos) {
            var array = (elements || []);
            if (!(pos >= 0)) {
                pos = 🔷getNodePos();
            }
            array.pos ⚠️= pos;
            array.end = pos;
            return array;
        }
Inlined functions:
getNodePos
() {
            return scanner.🔶getStartPos();
        }

parseObjectBindingElement:

() {
            var node = 🔷createNode(174);
            node.dotDotDotToken = 🔷parseOptionalToken(23);
            var tokenIsIdentifier = 🔶isIdentifier();
            var propertyName = 🔶parsePropertyName();
            if (tokenIsIdentifier && 🔶token() !== 55) {
                node.name = propertyName;
            }
            else {
                🔶parseExpected(55);
                node.propertyName = propertyName;
                node.name = 🔶parseIdentifierOrPattern();
            }
            node.initializer = 🔶parseBindingElementInitializer(false);
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseOptionalToken
(t) {
            if (🔷token() === t) {
                return 🔷parseTokenNode();
            }
            return undefined;
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔶nextToken();
            return 🔶finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

concatenate:

(array1, array2) {
        if (!🔷some(array2))
            return array1;
        if (!🔶️some(array1))
            return array2;
        return array1.🔶️concat(array2);
    }
Inlined functions:
some
(array, predicate) {
        if (array) {
            if (predicate) {
                for (var _i = 0, array_5 = array; _i ⚠️< array_5⚠️.length; _i++) {
                    var v = array_5⚠️[_i];
                    if (🔶️predicate(v)) {
                        return true;
                    }
                }
            }
            else {
                return array.length > 0;
            }
        }
        return false;
    }

getLanguageVariant:

(scriptKind) {
            return scriptKind === 4 || scriptKind === 2 || scriptKind === 1 ? 1 : 0;
        }

setOnError:

(errorCallback) {
            onError = errorCallback;
        }

isStartOfMappedType:

() {
            🔷nextToken();
            if (🔷token() === 130) {
                🔶nextToken();
            }
            return 🔷token() === 20 && 🔷nextTokenIsIdentifier() && 🔷nextToken() === 91;
        }
Inlined functions:
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
nextTokenIsIdentifier
() {
            🔷nextToken();
            return 🔷isIdentifier();
        }
Inlined functions:
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }

hasProperty:

(map, key) {
        return hasOwnProperty.🔶️call(map, key);
    }

parseJsxClosingElement:

(inExpressionContext) {
            var node = 🔷createNode(249);
            🔷parseExpected(27);
            node.tagName = 🔷parseJsxElementName();
            if (inExpressionContext) {
                🔶parseExpected(28);
            }
            else {
                🔶parseExpected(28, undefined, false);
                🔶scanJsxText();
            }
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
parseJsxElementName
() {
            🔷scanJsxIdentifier();
            var expression = 🔷token() === 98 ?
                🔶parseTokenNode() : 🔷parseIdentifierName();
            while (🔶parseOptional(22)) {
                var propertyAccess = 🔶createNode(177, expression⚠️.pos);
                propertyAccess.expression ⚠️= expression;
                propertyAccess.name ⚠️= parseRightSideOfDot(true);
                expression = 🔶finishNode(propertyAccess);
            }
            return expression;
        }
Inlined functions:
scanJsxIdentifier
() {
            return currentToken = scanner.🔶scanJsxIdentifier();
        }
token
() {
            return currentToken;
        }
parseIdentifierName
() {
            return 🔷createIdentifier(ts.🔷tokenIsIdentifierOrKeyword(🔷token()));
        }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
createIdentifier
(isIdentifier, diagnosticMessage) {
            identifierCount++;
            if (isIdentifier) {
                var node = 🔷createNode(70);
                if (🔶token() !== 70) {
                    node.originalKeywordKind = 🔶token();
                }
                node.text = 🔶️internIdentifier(scanner.🔶getTokenValue());
                🔶nextToken();
                return 🔶finishNode(node);
            }
            return 🔶️createMissingNode(70, false, diagnosticMessage || ts.Diagnostics.Identifier_expected);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔶️new IdentifierConstructor(kind, pos, pos) :
                    🔶️new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

⛔ tagNamesAreEquivalent (deoptimizated):

(lhs, rhs) {
            if (lhs.kind !== rhs.kind) {
                return false;
            }
            if (lhs.kind === 70) {
                return lhs.text === rhs.text;
            }
            if (lhs⚠️.kind ⚠️=== 98) {
                return true;
            }
            return lhs⚠️.name⚠️.text ⚠️=== rhs⚠️.name⚠️.text &&
                🔶tagNamesAreEquivalent(lhs⚠️.expression, rhs⚠️.expression);
        }
- Deopt: <JS Function parseIncrementExpression (SharedFunctionInfo 0x98bdb9ce879)> (opt #320) @49, FP to SP delta: 168, caller sp: 0x7fff5fbfcb90

parseArrowFunctionExpressionBody:

(isAsync) {
            if (🔷token() === 16) {
                return 🔶parseFunctionBlock(false, isAsync, false);
            }
            if (🔷token() !== 24 &&
                🔷token() !== 88 &&
                🔷token() !== 74 &&
                🔶isStartOfStatement() &&
                !🔷isStartOfExpressionStatement()) {
                return 🔶parseFunctionBlock(false, isAsync, true);
            }
            return isAsync
                ? 🔶️doInAwaitContext(parseAssignmentExpressionOrHigher)
                : 🔷doOutsideOfAwaitContext(parseAssignmentExpressionOrHigher);
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isStartOfExpressionStatement
() {
            return 🔷token() !== 16 &&
                🔷token() !== 88 &&
                🔷token() !== 74 &&
                🔷token() !== 56 &&
                🔶isStartOfExpression();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
doOutsideOfAwaitContext
(func) {
            return 🔷doOutsideOfContext(16384, func);
        }
Inlined functions:
doOutsideOfContext
(context, func) {
            var contextFlagsToClear = context & contextFlags;
            if (contextFlagsToClear) {
                🔶setContextFlag(false, contextFlagsToClear);
                var result = 🔶️func();
                🔶setContextFlag(true, contextFlagsToClear);
                return result;
            }
            return 🔶️func();
        }

parseDecorators:

() {
            var decorators;
            while (true) {
                var decoratorStart = 🔷getNodePos();
                if (!🔷parseOptional(56)) {
                    break;
                }
                var decorator = 🔷createNode(145, decoratorStart);
                decorator.expression = 🔷doInDecoratorContext(parseLeftHandSideExpressionOrHigher);
                🔶finishNode(decorator);
                if (!decorators) {
                    decorators = 🔶createNodeArray([decorator], decoratorStart);
                }
                else {
                    decorators.🔶️push(decorator);
                }
            }
            if (decorators) {
                decorators.end = 🔶getNodeEnd();
            }
            return decorators;
        }
Inlined functions:
getNodePos
() {
            return scanner.🔶getStartPos();
        }
parseOptional
(t) {
            if (🔷token() === t) {
                🔷nextToken();
                return true;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
doInDecoratorContext
(func) {
            return 🔷doInsideOfContext(8192, func);
        }
Inlined functions:
doInsideOfContext
(context, func) {
            var contextFlagsToSet = context & ~contextFlags;
            if (contextFlagsToSet) {
                🔷setContextFlag(true, contextFlagsToSet);
                var result = 🔷func();
                🔷setContextFlag(false, contextFlagsToSet);
                return result;
            }
            return 🔶️func();
        }
Inlined functions:
setContextFlag
(val, flag) {
            if (val) {
                contextFlags |= flag;
            }
            else {
                contextFlags &= ~flag;
            }
        }
func
() {
            var expression = 🔷token() === 96
                ? 🔷parseSuperExpression()
                : 🔷parseMemberExpressionOrHigher();
            return 🔶️parseCallExpressionRest(expression);
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseSuperExpression
() {
            var expression = 🔷parseTokenNode();
            if (🔷token() === 18 || 🔷token() === 22 || 🔶token() ⚠️=== 20) {
                return expression;
            }
            var node = 🔶createNode(177, expression⚠️.pos);
            node.expression ⚠️= expression;
            🔶parseExpectedToken(22, false, ts⚠️.Diagnostics⚠️.super_must_be_followed_by_an_argument_list_or_member_access);
            node.name ⚠️= parseRightSideOfDot(true);
            return 🔶finishNode(node);
        }
Inlined functions:
parseTokenNode
() {
            var node = 🔶createNode(🔶token());
            🔶nextToken();
            return 🔶finishNode(node);
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
parseMemberExpressionOrHigher
() {
            var expression = 🔶parsePrimaryExpression();
            return 🔶parseMemberExpressionRest(expression);
        }
setContextFlag
(val, flag) {
            if (val) {
                contextFlags |= flag;
            }
            else {
                contextFlags &= ~flag;
            }
        }

isConflictMarkerTrivia:

(text, pos) {
        ts.Debug.🔶️assert(pos >= 0);
        if (pos === 0 || 🔷isLineBreak(text.charCodeAt(pos - 1))) {
            var ch = text.🔶️charCodeAt(pos);
            if ((pos ⚠️+ mergeConflictMarkerLength) ⚠️< text⚠️.length) {
                for (var i = 0, n = mergeConflictMarkerLength; i ⚠️< n; i++) {
                    if (text.🔶️charCodeAt(pos ⚠️+ i) ⚠️!== ch) {
                        return false;
                    }
                }
                return ch ⚠️=== 61 ||
                    text.🔶️charCodeAt(pos ⚠️+ mergeConflictMarkerLength) ⚠️=== 32;
            }
        }
        return false;
    }
Inlined functions:
isLineBreak
(ch) {
        return ch === 10 ||
            ch === 13 ||
            ch === 8232 ||
            ch === 8233;
    }

parseObjectLiteralExpression:

() {
            var node = 🔷createNode(176);
            🔷parseExpected(16);
            if (scanner.🔶hasPrecedingLineBreak()) {
                node.multiLine = true;
            }
            node.properties = 🔶parseDelimitedList(12, parseObjectLiteralElement, true);
            🔷parseExpected(17);
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

resolveModuleName:

(moduleName, containingFile, compilerOptions, host) {
        var traceEnabled = 🔷isTraceEnabled(compilerOptions, host);
        if (traceEnabled) {
            🔶️trace(host, ts⚠️.Diagnostics⚠️.Resolving_module_0_from_1, moduleName, containingFile);
        }
        var moduleResolution = compilerOptions.moduleResolution;
        if (moduleResolution === undefined) {
            moduleResolution = ts.🔷getEmitModuleKind(compilerOptions) === ts.ModuleKind.CommonJS ? ts.ModuleResolutionKind.NodeJs : ts⚠️.ModuleResolutionKind⚠️.Classic;
            if (traceEnabled) {
                🔶️trace(host, ts⚠️.Diagnostics⚠️.Module_resolution_kind_is_not_specified_using_0, ts⚠️.ModuleResolutionKind⚠️[moduleResolution]);
            }
        }
        else {
            if (traceEnabled) {
                🔶️trace(host, ts⚠️.Diagnostics⚠️.Explicitly_specified_module_resolution_kind_Colon_0, ts⚠️.ModuleResolutionKind⚠️[moduleResolution]);
            }
        }
        var result;
        ⚠️switch (moduleResolution) {
            case ts.ModuleResolutionKind.NodeJs:
                result = 🔶nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host);
                break;
            case ts⚠️.ModuleResolutionKind⚠️.Classic:
                result = 🔶️classicNameResolver(moduleName, containingFile, compilerOptions, host);
                break;
        }
        if (traceEnabled) {
            if (result⚠️.resolvedModule) {
                🔶️trace(host, ts⚠️.Diagnostics⚠️.Module_name_0_was_successfully_resolved_to_1, moduleName, result⚠️.resolvedModule⚠️.resolvedFileName);
            }
            else {
                🔶️trace(host, ts⚠️.Diagnostics⚠️.Module_name_0_was_not_resolved, moduleName);
            }
        }
        return result;
    }
Inlined functions:
isTraceEnabled
(compilerOptions, host) {
        return compilerOptions.traceResolution && host⚠️.trace !== undefined;
    }
getEmitModuleKind
(compilerOptions) {
        return typeof compilerOptions.module === "number" ?
            compilerOptions.module :
            🔶getEmitScriptTarget(compilerOptions) ⚠️>= 2 ? ts⚠️.ModuleKind⚠️.ES2015 : ts⚠️.ModuleKind⚠️.CommonJS;
    }

nodeModuleNameResolver:

~recompile~
~recompile~
(moduleName, containingFile, compilerOptions, host) {
        var containingDirectory = ts.🔷getDirectoryPath(containingFile);
        var traceEnabled = 🔷isTraceEnabled(compilerOptions, host);
        var failedLookupLocations = [];
        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled };
        var result = 🔶️tryResolve(0) || 🔶️tryResolve(1);
        if (result) {
            var resolved = result.resolved, isExternalLibraryImport = result.isExternalLibraryImport;
            return 🔷createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations);
        }
        return { resolvedModule: undefined, failedLookupLocations: failedLookupLocations };
        🔶️function tryResolve(extensions) {
            var resolved = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, nodeLoadModuleByRelativeName, failedLookupLocations, state);
            if (resolved) {
                return { resolved: resolved, isExternalLibraryImport: false };
            }
            if (moduleHasNonRelativeName(moduleName)) {
                if (traceEnabled) {
                    trace(host, ts.Diagnostics.Loading_module_0_from_node_modules_folder, moduleName);
                }
                var resolved_1 = loadModuleFromNodeModules(extensions, moduleName, containingDirectory, failedLookupLocations, state);
                return resolved_1 && { resolved: { path: realpath(resolved_1.path, host, traceEnabled), extension: resolved_1.extension }, isExternalLibraryImport: true };
            }
            else {
                var candidate = ts.normalizePath(ts.combinePaths(containingDirectory, moduleName));
                var resolved_2 = nodeLoadModuleByRelativeName(extensions, candidate, failedLookupLocations, false, state);
                return resolved_2 && { resolved: resolved_2, isExternalLibraryImport: false };
            }
        }
    }
Inlined functions:
getDirectoryPath
(path) {
        return path.🔶substr(0, Math.max(🔶getRootLength(path), path.🔶lastIndexOf(ts.directorySeparator)));
    }
isTraceEnabled
(compilerOptions, host) {
        return compilerOptions.traceResolution && host⚠️.trace !== undefined;
    }
createResolvedModuleWithFailedLookupLocations
(resolved, isExternalLibraryImport, failedLookupLocations) {
        return { resolvedModule: resolved && 🔷resolvedModuleFromResolved(resolved, isExternalLibraryImport), failedLookupLocations: failedLookupLocations };
    }
Inlined functions:
resolvedModuleFromResolved
(_a, isExternalLibraryImport) {
        var path = _a.path, extension = _a.extension;
        return { resolvedFileName: path, extension: extension, isExternalLibraryImport: isExternalLibraryImport };
    }

⛔ getResolutionDiagnostic (deoptimizated):

~recompile~
~recompile~
(options, _a) {
        var extension = _a.extension;
        switch (extension) {
            case ts.Extension.Ts:
            case ts.Extension.Dts:
                return undefined;
            case ts.Extension.Tsx:
                return 🔶️needJsx();
            case ts.Extension.Jsx:
                return 🔶️needJsx() || 🔶️needAllowJs();
            case ts.Extension.Js:
                return 🔶️needAllowJs();
        }
        🔶️function needJsx() {
            return options.jsx ? undefined : ts.Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set;
        }
        🔶️function needAllowJs() {
            return options.allowJs ? undefined : ts.Diagnostics.Module_0_was_resolved_to_1_but_allowJs_is_not_set;
        }
    }
- Deopt: <JS Function getDeclarationOfAliasSymbol (SharedFunctionInfo 0x3f6f7cfa8519)> (opt #983) @4, FP to SP delta: 80, caller sp: 0x7fff5fbfcd60

readFile:

(fileName) { return ts.sys.🔶readFile(fileName); }

parseExpressionWithTypeArguments:

() {
            var node = 🔷createNode(199);
            node.expression = 🔷parseLeftHandSideExpressionOrHigher();
            if (🔶token() === 26) {
                node.typeArguments = 🔶parseBracketedList(19, parseType, 26, 28);
            }
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseLeftHandSideExpressionOrHigher
() {
            var expression = 🔷token() === 96
                ? 🔷parseSuperExpression()
                : 🔶parseMemberExpressionOrHigher();
            return 🔶️parseCallExpressionRest(expression);
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseSuperExpression
() {
            var expression = 🔷parseTokenNode();
            if (🔶token() === 18 || 🔶token() === 22 || 🔶token() ⚠️=== 20) {
                return expression;
            }
            var node = 🔶createNode(177, expression⚠️.pos);
            node.expression ⚠️= expression;
            🔶parseExpectedToken(22, false, ts⚠️.Diagnostics⚠️.super_must_be_followed_by_an_argument_list_or_member_access);
            node.name ⚠️= parseRightSideOfDot(true);
            return 🔶finishNode(node);
        }
Inlined functions:
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔶nextToken();
            return 🔶finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

parseTypeLiteral:

() {
            var node = 🔷createNode(161);
            node.members = 🔷parseObjectTypeMembers();
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseObjectTypeMembers
() {
            var members;
            if (🔷parseExpected(16)) {
                members = 🔶parseList(4, parseTypeMember);
                🔷parseExpected(17);
            }
            else {
                members = 🔶️createMissingList();
            }
            return members;
        }
Inlined functions:
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

parseObjectLiteralElement:

() {
            var fullStart = scanner.getStartPos();
            var dotDotDotToken = 🔷parseOptionalToken(23);
            if (dotDotDotToken) {
                var spreadElement = 🔶createNode(259, fullStart);
                spreadElement.expression ⚠️= parseAssignmentExpressionOrHigher();
                return 🔶addJSDocComment(🔶finishNode(spreadElement));
            }
            var decorators = parseDecorators();
            var modifiers = parseModifiers();
            var accessor = 🔷tryParseAccessorDeclaration(fullStart, decorators, modifiers);
            if (accessor) {
                return accessor;
            }
            var asteriskToken = 🔶parseOptionalToken(38);
            var tokenIsIdentifier = 🔶isIdentifier();
            var propertyName = 🔶parsePropertyName();
            var questionToken = 🔶parseOptionalToken(54);
            if (asteriskToken || 🔶token() === 18 || 🔶token() === 26) {
                return 🔶parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, propertyName, questionToken);
            }
            var isShorthandPropertyAssignment = tokenIsIdentifier && (🔶token() === 25 || 🔶token() === 17 || 🔶token() === 57);
            if (isShorthandPropertyAssignment) {
                var shorthandDeclaration = createNode(258, fullStart);
                shorthandDeclaration.name = propertyName;
                shorthandDeclaration.questionToken = questionToken;
                var equalsToken = 🔶parseOptionalToken(57);
                if (equalsToken) {
                    shorthandDeclaration.equalsToken ⚠️= equalsToken;
                    shorthandDeclaration.objectAssignmentInitializer ⚠️= allowInAnd(parseAssignmentExpressionOrHigher);
                }
                return 🔶addJSDocComment(🔶finishNode(shorthandDeclaration));
            }
            else {
                var propertyAssignment = createNode(257, fullStart);
                propertyAssignment.modifiers = modifiers;
                propertyAssignment.name = propertyName;
                propertyAssignment.questionToken = questionToken;
                🔶parseExpected(55);
                propertyAssignment.initializer = 🔶allowInAnd(parseAssignmentExpressionOrHigher);
                return 🔶addJSDocComment(🔶finishNode(propertyAssignment));
            }
        }
Inlined functions:
parseOptionalToken
(t) {
            if (🔷token() === t) {
                return 🔷parseTokenNode();
            }
            return undefined;
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔷nextToken();
            return 🔷finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }
tryParseAccessorDeclaration
(fullStart, decorators, modifiers) {
            if (🔷parseContextualModifier(124)) {
                return 🔷parseAccessorDeclaration(151, fullStart, decorators, modifiers);
            }
            else if (🔶parseContextualModifier(133)) {
                return 🔶️parseAccessorDeclaration(152, fullStart, decorators, modifiers);
            }
            return undefined;
        }
Inlined functions:
parseContextualModifier
(t) {
            return 🔷token() === t && 🔷tryParse(nextTokenCanFollowModifier);
        }
Inlined functions:
token
() {
            return currentToken;
        }
tryParse
(callback) {
            return 🔶speculationHelper(callback, false);
        }
parseAccessorDeclaration
(kind, fullStart, decorators, modifiers) {
            var node = 🔷createNode(kind, fullStart);
            node.decorators = decorators;
            node.modifiers = modifiers;
            node.name = 🔶parsePropertyName();
            🔶fillSignature(55, false, false, false, node);
            node.body = 🔶parseFunctionBlockOrSemicolon(false, false);
            return 🔶addJSDocComment(🔶finishNode(node));
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔶️new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

getTrailingCommentRanges:

(text, pos) {
        return 🔷reduceEachTrailingCommentRange(text, pos, appendCommentRange, undefined, undefined);
    }
Inlined functions:
reduceEachTrailingCommentRange
(text, pos, cb, state, initial) {
        return 🔶iterateCommentRanges(true, text, pos, true, cb, state, initial);
    }

parseHeritageClause:

() {
            if (🔷token() === 84 || 🔷token() === 107) {
                var node = 🔷createNode(255);
                node.token = 🔷token();
                🔷nextToken();
                node.types = 🔶parseDelimitedList(7, parseExpressionWithTypeArguments);
                return 🔷finishNode(node);
            }
            return undefined;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }

isUpdateExpression:

() {
            switch (🔷token()) {
                case 36:
                case 37:
                case 51:
                case 50:
                case 79:
                case 102:
                case 104:
                case 120:
                    return false;
                case 26:
                    if (sourceFile.languageVariant !== 1) {
                        return false;
                    }
                default:
                    return true;
            }
        }
Inlined functions:
token
() {
            return currentToken;
        }

⛔ findSourceFile (deoptimizated):

~recompile~
- Deopt: <JS Function tryExtension (SharedFunctionInfo 0x1e745f8519c1)> (opt #199) @19, FP to SP delta: 64, caller sp: 0x7fff5fbfdbc8
- Deopt: <JS Function parseImportClause (SharedFunctionInfo 0x98bdb9d3af9)> (opt #269) @48, FP to SP delta: 80, caller sp: 0x7fff5fbfda68
~recompile~
(fileName, path, isDefaultLib, refFile, refPos, refEnd) {
            if (filesByName.🔶contains(path)) {
                var file_1 = filesByName.get(path);
                if (file_1 && options.forceConsistentCasingInFileNames && ts.🔶getNormalizedAbsolutePath(file_1⚠️.fileName, currentDirectory) ⚠️!== ts.🔶getNormalizedAbsolutePath(fileName, currentDirectory)) {
                    🔶️reportFileNamesDifferOnlyInCasingError(fileName, file_1⚠️.fileName, refFile, refPos, refEnd);
                }
                if (file_1 && sourceFilesFoundSearchingNodeModules⚠️[file_1⚠️.path] && currentNodeModulesDepth == 0) {
                    sourceFilesFoundSearchingNodeModules[file_1.path] ⚠️= false;
                    if (!options.noResolve) {
                        🔶processReferencedFiles(file_1, isDefaultLib);
                        🔶️processTypeReferenceDirectives(file_1);
                    }
                    modulesWithElidedImports[file_1.path] ⚠️= false;
                    🔶️processImportedModules(file_1);
                }
                else if (file_1 && modulesWithElidedImports⚠️[file_1⚠️.path]) {
                    if (currentNodeModulesDepth ⚠️< maxNodeModuleJsDepth) {
                        modulesWithElidedImports[file_1⚠️.path] ⚠️= false;
                        🔶️processImportedModules(file_1);
                    }
                }
                return file_1;
            }
            var file = host.getSourceFile(fileName, options.target, 🔶️function (hostErrorMessage) {
                if (refFile !== undefined && refPos !== undefined && refEnd !== undefined) {
                    fileProcessingDiagnostics.add(ts.createFileDiagnostic(refFile, refPos, refEnd - refPos, ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage));
                }
                else {
                    fileProcessingDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage));
                }
            });
            filesByName.🔶️set(path, file);
            if (file) {
                sourceFilesFoundSearchingNodeModules[path] ⚠️= (currentNodeModulesDepth > 0);
                file.path ⚠️= path;
                if (host.🔶useCaseSensitiveFileNames()) {
                    var existingFile = filesByNameIgnoreCase.⚠️get(path);
                    if (existingFile) {
                        🔶️reportFileNamesDifferOnlyInCasingError(fileName, existingFile⚠️.fileName, refFile, refPos, refEnd);
                    }
                    else {
                        filesByNameIgnoreCase.🔶️set(path, file);
                    }
                }
                skipDefaultLib = skipDefaultLib || file⚠️.hasNoDefaultLib;
                if (!options.noResolve) {
                    🔶processReferencedFiles(file, isDefaultLib);
                    🔶️processTypeReferenceDirectives(file);
                }
                🔶️processImportedModules(file);
                if (isDefaultLib) {
                    files.🔶️unshift(file);
                }
                else {
                    files.🔶️push(file);
                }
            }
            return file;
        }

parseSimpleUnaryExpression:

() {
            switch (🔷token()) {
                case 36:
                case 37:
                case 51:
                case 50:
                    return 🔷parsePrefixUnaryExpression();
                case 79:
                    return 🔶️parseDeleteExpression();
                case 102:
                    return 🔷parseTypeOfExpression();
                case 104:
                    return 🔶️parseVoidExpression();
                case 26:
                    return 🔶️parseTypeAssertion();
                case 120:
                    if (🔶️isAwaitExpression()) {
                        return 🔶️parseAwaitExpression();
                    }
                default:
                    return 🔶parseIncrementExpression();
            }
        }
Inlined functions:
token
() {
            return currentToken;
        }
parsePrefixUnaryExpression
() {
            var node = 🔷createNode(190);
            node.operator = 🔷token();
            🔷nextToken();
            node.operand = 🔶parseSimpleUnaryExpression();
            return 🔷finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }
parseTypeOfExpression
() {
            var node = 🔷createNode(187);
            🔶nextToken();
            node.expression = 🔶parseSimpleUnaryExpression();
            return 🔶finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

isHeritageClause:

() {
            return 🔷token() === 84 || 🔷token() === 107;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

parseArrayTypeOrHigher:

~recompile~
~recompile~
() {
            var type = 🔶parseNonArrayType();
            while (!scanner.🔶hasPrecedingLineBreak() && 🔷parseOptional(20)) {
                if (🔶isStartOfType()) {
                    var node = 🔷createNode(169, type.pos);
                    node.objectType = type;
                    node.indexType = 🔷parseType();
                    🔷parseExpected(21);
                    type = 🔶finishNode(node);
                }
                else {
                    var node = 🔶createNode(162, type⚠️.pos);
                    node.elementType = type;
                    🔶parseExpected(21);
                    type = 🔶finishNode(node);
                }
            }
            return type;
        }
Inlined functions:
parseOptional
(t) {
            if (🔷token() === t) {
                🔷nextToken();
                return true;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseType
() {
            return 🔷doOutsideOfContext(20480, parseTypeWorker);
        }
Inlined functions:
doOutsideOfContext
(context, func) {
            var contextFlagsToClear = context & contextFlags;
            if (contextFlagsToClear) {
                🔶setContextFlag(false, contextFlagsToClear);
                var result = 🔶️func();
                🔶setContextFlag(true, contextFlagsToClear);
                return result;
            }
            return 🔶️func();
        }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }

parseFunctionDeclaration:

(fullStart, decorators, modifiers) {
            var node = 🔷createNode(225, fullStart);
            node.decorators = decorators;
            node.modifiers = modifiers;
            🔷parseExpected(88);
            node.asteriskToken = 🔷parseOptionalToken(38);
            node.name = ts.🔶hasModifier(node, 512) ? 🔶️parseOptionalIdentifier() : 🔶parseIdentifier();
            var isGenerator = !!node.asteriskToken;
            var isAsync = ts.🔶hasModifier(node, 256);
            🔶fillSignature(55, isGenerator, isAsync, false, node);
            node.body = 🔶parseFunctionBlockOrSemicolon(isGenerator, isAsync, ts.Diagnostics.or_expected);
            return 🔶addJSDocComment(🔶finishNode(node));
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
parseOptionalToken
(t) {
            if (🔷token() === t) {
                return 🔷parseTokenNode();
            }
            return undefined;
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔶nextToken();
            return 🔶finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔶️new IdentifierConstructor(kind, pos, pos) :
                    🔶️new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

addJSDocComment:

~recompile~
~recompile~
~recompile~
(node) {
            var comments = ts.getJSDocCommentRanges(node, sourceFile.text);
            if (comments) {
                for (var _i = 0, comments_2 = comments; _i < comments_2.length; _i++) {
                    var comment = comments_2[_i];
                    var jsDoc = JSDocParser.🔶parseJSDocComment(node, comment.pos, comment.end - comment.pos);
                    if (!jsDoc) {
                        continue;
                    }
                    if (!node⚠️.jsDoc) {
                        node.jsDoc ⚠️= [];
                    }
                    node.jsDoc.push(jsDoc);
                }
            }
            return node;
        }

⛔ realpath (deoptimizated):

~recompile~
~recompile~
~recompile~
(path) {
                    return _fs.🔶realpathSync(path);
                }
- Deopt: <JS Function findSourceFile (SharedFunctionInfo 0x3901d38f6429)> (opt #361) @51, FP to SP delta: 96, caller sp: 0x7fff5fbfdc60
- Deopt: <JS Function findSourceFile (SharedFunctionInfo 0x3901d38f6429)> (opt #361) @36, FP to SP delta: 96, caller sp: 0x7fff5fbfdda0

skipParameterStart:

() {
            if (ts.🔷isModifierKind(🔷token())) {
                🔶parseModifiers();
            }
            if (🔷isIdentifier() || 🔷token() === 98) {
                🔷nextToken();
                return true;
            }
            if (🔷token() === 20 || 🔷token() === 16) {
                var previousErrorCount = parseDiagnostics⚠️.length;
                🔶parseIdentifierOrPattern();
                return previousErrorCount ⚠️=== parseDiagnostics⚠️.length;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
isModifierKind
(token) {
        switch (token) {
            case 116:
            case 119:
            case 75:
            case 123:
            case 78:
            case 83:
            case 113:
            case 111:
            case 112:
            case 130:
            case 114:
                return true;
        }
        return false;
    }
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

parseVariableDeclarationList:

(inForStatementInitializer) {
            var node = 🔷createNode(224);
            switch (🔷token()) {
                case 103:
                    break;
                case 109:
                    node.flags |= 1;
                    break;
                case 75:
                    node.flags |= 2;
                    break;
                default:
                    ts⚠️.Debug.⚠️fail();
            }
            🔷nextToken();
            if (🔷token() === 140 && 🔶lookAhead(canFollowContextualOfKeyword)) {
                node.declarations ⚠️= createMissingList();
            }
            else {
                var savedDisallowIn = 🔷inDisallowInContext();
                🔷setDisallowInContext(inForStatementInitializer);
                node.declarations = 🔶parseDelimitedList(8, parseVariableDeclaration);
                🔷setDisallowInContext(savedDisallowIn);
            }
            return 🔷finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
token
() {
            return currentToken;
        }
inDisallowInContext
() {
            return 🔷inContext(2048);
        }
Inlined functions:
inContext
(flags) {
            return (contextFlags & flags) !== 0;
        }
setDisallowInContext
(val) {
            🔷setContextFlag(val, 2048);
        }
Inlined functions:
setContextFlag
(val, flag) {
            if (val) {
                contextFlags |= flag;
            }
            else {
                contextFlags &= ~flag;
            }
        }
setDisallowInContext
(val) {
            🔷setContextFlag(val, 2048);
        }
Inlined functions:
setContextFlag
(val, flag) {
            if (val) {
                contextFlags |= flag;
            }
            else {
                contextFlags &= ~flag;
            }
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }

parseThisTypeNode:

() {
            var node = 🔷createNode(167);
            🔷nextToken();
            return 🔷finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }

isUnambiguouslyStartOfFunctionType:

() {
            🔷nextToken();
            if (🔷token() === 19 || 🔷token() === 23) {
                return true;
            }
            if (🔷skipParameterStart()) {
                if (🔷token() === 55 || 🔷token() === 25 ||
                    🔷token() === 54 || 🔷token() === 57) {
                    return true;
                }
                if (🔷token() === 19) {
                    🔶nextToken();
                    if (🔶token() ⚠️=== 35) {
                        return true;
                    }
                }
            }
            return false;
        }
Inlined functions:
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
skipParameterStart
() {
            if (ts.🔷isModifierKind(🔷token())) {
                🔶parseModifiers();
            }
            if (🔷isIdentifier() || 🔷token() === 98) {
                🔷nextToken();
                return true;
            }
            if (🔷token() === 20 || 🔷token() === 16) {
                var previousErrorCount = parseDiagnostics⚠️.length;
                🔶parseIdentifierOrPattern();
                return previousErrorCount ⚠️=== parseDiagnostics⚠️.length;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
isModifierKind
(token) {
        switch (token) {
            case 116:
            case 119:
            case 75:
            case 123:
            case 78:
            case 83:
            case 113:
            case 111:
            case 112:
            case 130:
            case 114:
                return true;
        }
        return false;
    }
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

parseJSDocIdentifierName:

() {
                    return 🔶createJSDocIdentifier(ts.🔷tokenIsIdentifierOrKeyword(🔷token()));
                }
Inlined functions:
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }

⛔ isExternalModuleNameRelative (deoptimizated):

(moduleName) {
        return 🔶️/^\x5c.\x5c.?($|[\🔶️x5c\x5c/])/.test(moduleName);
    }
- Deopt: <JS Function loader_1 (SharedFunctionInfo 0x3901d38f6d29)> (opt #278) @3, FP to SP delta: 24, caller sp: 0x7fff5fbfdcd8

parseClassDeclarationOrExpression:

(fullStart, decorators, modifiers, kind) {
            var node = 🔷createNode(kind, fullStart);
            node.decorators = decorators;
            node.modifiers = modifiers;
            🔷parseExpected(74);
            node.name = 🔷parseNameOfClassDeclarationOrExpression();
            node.typeParameters = 🔶parseTypeParameters();
            node.heritageClauses = 🔶parseHeritageClauses();
            if (🔶parseExpected(16)) {
                node.members = 🔶parseClassMembers();
                🔶parseExpected(17);
            }
            else {
                node.members ⚠️= createMissingList();
            }
            return 🔶addJSDocComment(🔶finishNode(node));
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
parseNameOfClassDeclarationOrExpression
() {
            return 🔷isIdentifier() && !🔷isImplementsClause()
                ? 🔶parseIdentifier()
                : undefined;
        }
Inlined functions:
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
isImplementsClause
() {
            return 🔷token() === 107 && 🔶lookAhead(nextTokenIsIdentifierOrKeyword);
        }
Inlined functions:
token
() {
            return currentToken;
        }

parseClassMembers:

() {
            return 🔶parseList(5, parseClassElement);
        }

resolvedModuleFromResolved:

(_a, isExternalLibraryImport) {
        var path = _a.path, extension = _a.extension;
        return { resolvedFileName: path, extension: extension, isExternalLibraryImport: isExternalLibraryImport };
    }

isTrivia:

(token) {
        return 2 <= token && token <= 7;
    }

loadModuleFromNodeModules:

(extensions, moduleName, directory, failedLookupLocations, state) {
        return 🔶loadModuleFromNodeModulesWorker(extensions, moduleName, directory, failedLookupLocations, state, false);
    }

loadModuleFromNodeModulesWorker:

(extensions, moduleName, directory, failedLookupLocations, state, typesOnly) {
        return 🔷forEachAncestorDirectory(ts.🔷normalizeSlashes(directory), 🔶️function (ancestorDirectory) {
            if (ts.getBaseFileName(ancestorDirectory) !== "node_modules") {
                return loadModuleFromNodeModulesOneLevel(extensions, moduleName, ancestorDirectory, failedLookupLocations, state, typesOnly);
            }
        });
    }
Inlined functions:
normalizeSlashes
(path) {
        return path.🔶️replace(🔶️/\x5c\x5c/g, "/");
    }
forEachAncestorDirectory
(directory, callback) {
        while (true) {
            var result = 🔶️callback(directory);
            if (result !== undefined) {
                return result;
            }
            var parentPath = ts.🔷getDirectoryPath(directory);
            if (parentPath === directory) {
                return undefined;
            }
            directory = parentPath;
        }
    }
Inlined functions:
getDirectoryPath
(path) {
        return path.🔶substr(0, Math.max(🔶getRootLength(path), path.🔶lastIndexOf(ts.directorySeparator)));
    }

parseJSDocCommentWorker:

(start, length) {
                var content = sourceText;
                start = start || 0;
                var end = length === undefined ? content⚠️.length : start + length;
                length = end - start;
                ts.Debug.🔶️assert(start >= 0);
                ts.Debug.🔶️assert(start <= end);
                ts.Debug.🔶️assert(end <= content.length);
                var tags;
                var comments = [];
                var result;
                if (!🔶️isJsDocStart(content, start)) {
                    return result;
                }
                scanner.🔶️scanRange(start + 3, length - 5, 🔶️function () {
                    var advanceToken = true;
                    var state = 1;
                    var margin = undefined;
                    var indent = start - Math.max(content.lastIndexOf("\x5cn", start), 0) + 4;
                    function pushComment(text) {
                        if (!margin) {
                            margin = indent;
                        }
                        comments.push(text);
                        indent += text.length;
                    }
                    nextJSDocToken();
                    while (token() === 5) {
                        nextJSDocToken();
                    }
                    if (token() === 4) {
                        state = 0;
                        indent = 0;
                        nextJSDocToken();
                    }
                    while (token() !== 1) {
                        switch (token()) {
                            case 56:
                                if (state === 0 || state === 1) {
                                    removeTrailingNewlines(comments);
                                    parseTag(indent);
                                    state = 0;
                                    advanceToken = false;
                                    margin = undefined;
                                    indent++;
                                }
                                else {
                                    pushComment(scanner.getTokenText());
                                }
                                break;
                            case 4:
                                comments.push(scanner.getTokenText());
                                state = 0;
                                indent = 0;
                                break;
                            case 38:
                                var asterisk = scanner.getTokenText();
                                if (state === 1) {
                                    state = 2;
                                    pushComment(asterisk);
                                }
                                else {
                                    state = 1;
                                    indent += asterisk.length;
                                }
                                break;
                            case 70:
                                pushComment(scanner.getTokenText());
                                state = 2;
                                break;
                            case 5:
                                var whitespace = scanner.getTokenText();
                                if (state === 2 || margin !== undefined && indent + whitespace.length > margin) {
                                    comments.push(whitespace.slice(margin - indent - 1));
                                }
                                indent += whitespace.length;
                                break;
                            case 1:
                                break;
                            default:
                                pushComment(scanner.getTokenText());
                                break;
                        }
                        if (advanceToken) {
                            nextJSDocToken();
                        }
                        else {
                            advanceToken = true;
                        }
                    }
                    removeLeadingNewlines(comments);
                    removeTrailingNewlines(comments);
                    result = createJSDocComment();
                });
                return result;
             🔶️   function removeLeadingNewlines(comments) {
                    while (comments.length && (comments[0] === "\x5cn" || comments[0] === "\x5cr")) {
                        comments.shift();
                    }
                }
       🔶️         function removeTrailingNewlines(comments) {
                    while (comments.length && (comments[comments.length - 1] === "\x5cn" || comments[comments.length - 1] === "\x5cr")) {
                        comments.pop();
                    }
                }
 🔶️               function isJsDocStart(content, start) {
                    return content.charCodeAt(start) === 47 &&
                        content.charCodeAt(start + 1) === 42 &&
                        content.charCodeAt(start + 2) === 42 &&
                        content.charCodeAt(start + 3) !== 42;
                }
 🔶️               function createJSDocComment() {
                    var result = createNode(278, start);
                    result.tags = tags;
                    result.comment = comments.length ? comments.join("") : undefined;
                    return finishNode(result, end);
                }
 🔶️               function skipWhitespace() {
                    while (token() === 5 || token() === 4) {
                        nextJSDocToken();
                    }
                }
 🔶️               function parseTag(indent) {
                    ts.Debug.assert(token() === 56);
                    var atToken = createNode(56, scanner.getTokenPos());
                    atToken.end = scanner.getTextPos();
                    nextJSDocToken();
                    var tagName = parseJSDocIdentifierName();
                    skipWhitespace();
                    if (!tagName) {
                        return;
                    }
                    var tag;
                    if (tagName) {
                        switch (tagName.text) {
                            case "augments":
                                tag = parseAugmentsTag(atToken, tagName);
                                break;
                            case "param":
                                tag = parseParamTag(atToken, tagName);
                                break;
                            case "return":
                            case "returns":
                                tag = parseReturnTag(atToken, tagName);
                                break;
                            case "template":
                                tag = parseTemplateTag(atToken, tagName);
                                break;
                            case "type":
                                tag = parseTypeTag(atToken, tagName);
                                break;
                            case "typedef":
                                tag = parseTypedefTag(atToken, tagName);
                                break;
                            default:
                                tag = parseUnknownTag(atToken, tagName);
                                break;
                        }
                    }
                    else {
                        tag = parseUnknownTag(atToken, tagName);
                    }
                    if (!tag) {
                        return;
                    }
                    addTag(tag, parseTagComments(indent + tag.end - tag.pos));
                }
 🔶️               function parseTagComments(indent) {
                    var comments = [];
                    var state = 1;
                    var margin;
                    function pushComment(text) {
                        if (!margin) {
                            margin = indent;
                        }
                        comments.push(text);
                        indent += text.length;
                    }
                    while (token() !== 56 && token() !== 1) {
                        switch (token()) {
                            case 4:
                                if (state >= 1) {
                                    state = 0;
                                    comments.push(scanner.getTokenText());
                                }
                                indent = 0;
                                break;
                            case 56:
                                break;
                            case 5:
                                if (state === 2) {
                                    pushComment(scanner.getTokenText());
                                }
                                else {
                                    var whitespace = scanner.getTokenText();
                                    if (margin !== undefined && indent + whitespace.length > margin) {
                                        comments.push(whitespace.slice(margin - indent - 1));
                                    }
                                    indent += whitespace.length;
                                }
                                break;
                            case 38:
                                if (state === 0) {
                                    state = 1;
                                    indent += scanner.getTokenText().length;
                                    break;
                                }
                            default:
                                state = 2;
                                pushComment(scanner.getTokenText());
                                break;
                        }
                        if (token() === 56) {
                            break;
                        }
                        nextJSDocToken();
                    }
                    removeLeadingNewlines(comments);
                    removeTrailingNewlines(comments);
                    return comments;
                }
 🔶️               function parseUnknownTag(atToken, tagName) {
                    var result = createNode(279, atToken.pos);
                    result.atToken = atToken;
                    result.tagName = tagName;
                    return finishNode(result);
                }
 🔶️               function addTag(tag, comments) {
                    tag.comment = comments.join("");
                    if (!tags) {
                        tags = createNodeArray([tag], tag.pos);
                    }
                    else {
                        tags.push(tag);
                    }
                    tags.end = tag.end;
                }
 🔶️               function tryParseTypeExpression() {
                    return tryParse(function () {
                        skipWhitespace();
                        if (token() !== 16) {
                            return undefined;
                        }
                        return parseJSDocTypeExpression();
                    });
                }
 🔶️               function parseParamTag(atToken, tagName) {
                    var typeExpression = tryParseTypeExpression();
                    skipWhitespace();
                    var name;
                    var isBracketed;
                    if (parseOptionalToken(20)) {
                        name = parseJSDocIdentifierName();
                        skipWhitespace();
                        isBracketed = true;
                        if (parseOptionalToken(57)) {
                            parseExpression();
                        }
                        parseExpected(21);
                    }
                    else if (ts.tokenIsIdentifierOrKeyword(token())) {
                        name = parseJSDocIdentifierName();
                    }
                    if (!name) {
                        parseErrorAtPosition(scanner.getStartPos(), 0, ts.Diagnostics.Identifier_expected);
                        return undefined;
                    }
                    var preName, postName;
                    if (typeExpression) {
                        postName = name;
                    }
                    else {
                        preName = name;
                    }
                    if (!typeExpression) {
                        typeExpression = tryParseTypeExpression();
                    }
                    var result = createNode(281, atToken.pos);
                    result.atToken = atToken;
                    result.tagName = tagName;
                    result.preParameterName = preName;
                    result.typeExpression = typeExpression;
                    result.postParameterName = postName;
                    result.parameterName = postName || preName;
                    result.isBracketed = isBracketed;
                    return finishNode(result);
                }
 🔶️               function parseReturnTag(atToken, tagName) {
                    if (ts.forEach(tags, function (t) { return t.kind === 282; })) {
                        parseErrorAtPosition(tagName.pos, scanner.getTokenPos() - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text);
                    }
                    var result = createNode(282, atToken.pos);
                    result.atToken = atToken;
                    result.tagName = tagName;
                    result.typeExpression = tryParseTypeExpression();
                    return finishNode(result);
                }
 🔶️               function parseTypeTag(atToken, tagName) {
                    if (ts.forEach(tags, function (t) { return t.kind === 283; })) {
                        parseErrorAtPosition(tagName.pos, scanner.getTokenPos() - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text);
                    }
                    var result = createNode(283, atToken.pos);
                    result.atToken = atToken;
                    result.tagName = tagName;
                    result.typeExpression = tryParseTypeExpression();
                    return finishNode(result);
                }
 🔶️               function parsePropertyTag(atToken, tagName) {
                    var typeExpression = tryParseTypeExpression();
                    skipWhitespace();
                    var name = parseJSDocIdentifierName();
                    skipWhitespace();
                    if (!name) {
                        parseErrorAtPosition(scanner.getStartPos(), 0, ts.Diagnostics.Identifier_expected);
                        return undefined;
                    }
                    var result = createNode(286, atToken.pos);
                    result.atToken = atToken;
                    result.tagName = tagName;
                    result.name = name;
                    result.typeExpression = typeExpression;
                    return finishNode(result);
                }
 🔶️               function parseAugmentsTag(atToken, tagName) {
                    var typeExpression = tryParseTypeExpression();
                    var result = createNode(280, atToken.pos);
                    result.atToken = atToken;
                    result.tagName = tagName;
                    result.typeExpression = typeExpression;
                    return finishNode(result);
                }
 🔶️               function parseTypedefTag(atToken, tagName) {
                    var typeExpression = tryParseTypeExpression();
                    skipWhitespace();
                    var typedefTag = createNode(285, atToken.pos);
                    typedefTag.atToken = atToken;
                    typedefTag.tagName = tagName;
                    typedefTag.fullName = parseJSDocTypeNameWithNamespace(0);
                    if (typedefTag.fullName) {
                        var rightNode = typedefTag.fullName;
                        while (rightNode.kind !== 70) {
                            rightNode = rightNode.body;
                        }
                        typedefTag.name = rightNode;
                    }
                    typedefTag.typeExpression = typeExpression;
                    skipWhitespace();
                    if (typeExpression) {
                        if (typeExpression.type.kind === 272) {
                            var jsDocTypeReference = typeExpression.type;
                            if (jsDocTypeReference.name.kind === 70) {
                                var name_14 = jsDocTypeReference.name;
                                if (name_14.text === "Object") {
                                    typedefTag.jsDocTypeLiteral = scanChildTags();
                                }
                            }
                        }
                        if (!typedefTag.jsDocTypeLiteral) {
                            typedefTag.jsDocTypeLiteral = typeExpression.type;
                        }
                    }
                    else {
                        typedefTag.jsDocTypeLiteral = scanChildTags();
                    }
                    return finishNode(typedefTag);
                    function scanChildTags() {
                        var jsDocTypeLiteral = createNode(287, scanner.getStartPos());
                        var resumePos = scanner.getStartPos();
                        var canParseTag = true;
                        var seenAsterisk = false;
                        var parentTagTerminated = false;
                        while (token() !== 1 && !parentTagTerminated) {
                            nextJSDocToken();
                            switch (token()) {
                                case 56:
                                    if (canParseTag) {
                                        parentTagTerminated = !tryParseChildTag(jsDocTypeLiteral);
                                        if (!parentTagTerminated) {
                                            resumePos = scanner.getStartPos();
                                        }
                                    }
                                    seenAsterisk = false;
                                    break;
                                case 4:
                                    resumePos = scanner.getStartPos() - 1;
                                    canParseTag = true;
                                    seenAsterisk = false;
                                    break;
                                case 38:
                                    if (seenAsterisk) {
                                        canParseTag = false;
                                    }
                                    seenAsterisk = true;
                                    break;
                                case 70:
                                    canParseTag = false;
                                case 1:
                                    break;
                            }
                        }
                        scanner.setTextPos(resumePos);
                        return finishNode(jsDocTypeLiteral);
                    }
                    function parseJSDocTypeNameWithNamespace(flags) {
                        var pos = scanner.getTokenPos();
                        var typeNameOrNamespaceName = parseJSDocIdentifierName();
                        if (typeNameOrNamespaceName && parseOptional(22)) {
                            var jsDocNamespaceNode = createNode(230, pos);
                            jsDocNamespaceNode.flags |= flags;
                            jsDocNamespaceNode.name = typeNameOrNamespaceName;
                            jsDocNamespaceNode.body = parseJSDocTypeNameWithNamespace(4);
                            return jsDocNamespaceNode;
                        }
                        if (typeNameOrNamespaceName && flags & 4) {
                            typeNameOrNamespaceName.isInJSDocNamespace = true;
                        }
                        return typeNameOrNamespaceName;
                    }
                }
 🔶️               function tryParseChildTag(parentTag) {
                    ts.Debug.assert(token() === 56);
                    var atToken = createNode(56, scanner.getStartPos());
                    atToken.end = scanner.getTextPos();
                    nextJSDocToken();
                    var tagName = parseJSDocIdentifierName();
                    skipWhitespace();
                    if (!tagName) {
                        return false;
                    }
                    switch (tagName.text) {
                        case "type":
                            if (parentTag.jsDocTypeTag) {
                                return false;
                            }
                            parentTag.jsDocTypeTag = parseTypeTag(atToken, tagName);
                            return true;
                        case "prop":
                        case "property":
                            var propertyTag = parsePropertyTag(atToken, tagName);
                            if (propertyTag) {
                                if (!parentTag.jsDocPropertyTags) {
                                    parentTag.jsDocPropertyTags = [];
                                }
                                parentTag.jsDocPropertyTags.push(propertyTag);
                                return true;
                            }
                            return false;
                    }
                    return false;
                }
 🔶️               function parseTemplateTag(atToken, tagName) {
                    if (ts.forEach(tags, function (t) { return t.kind === 284; })) {
                        parseErrorAtPosition(tagName.pos, scanner.getTokenPos() - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text);
                    }
                    var typeParameters = createNodeArray();
                    while (true) {
                        var name_15 = parseJSDocIdentifierName();
                        skipWhitespace();
                        if (!name_15) {
                            parseErrorAtPosition(scanner.getStartPos(), 0, ts.Diagnostics.Identifier_expected);
                            return undefined;
                        }
                        var typeParameter = createNode(143, name_15.pos);
                        typeParameter.name = name_15;
                        finishNode(typeParameter);
                        typeParameters.push(typeParameter);
                        if (token() === 25) {
                            nextJSDocToken();
                            skipWhitespace();
                        }
                        else {
                            break;
                        }
                    }
                    var result = createNode(284, atToken.pos);
                    result.atToken = atToken;
                    result.tagName = tagName;
                    result.typeParameters = typeParameters;
                    finishNode(result);
                    typeParameters.end = result.end;
                    return result;
                }
 🔶️               function nextJSDocToken() {
                    return currentToken = scanner.scanJSDocToken();
                }
 🔶️               function parseJSDocIdentifierName() {
                    return createJSDocIdentifier(ts.tokenIsIdentifierOrKeyword(token()));
                }
 🔶️               function createJSDocIdentifier(isIdentifier) {
                    if (!isIdentifier) {
                        parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected);
                        return undefined;
                    }
                    var pos = scanner.getTokenPos();
                    var end = scanner.getTextPos();
                    var result = createNode(70, pos);
                    result.text = content.substring(pos, end);
                    finishNode(result, end);
                    nextJSDocToken();
                    return result;
                }
            }

tryParseTypeExpression:

() {
                    return 🔷tryParse(🔶️function () {
                        skipWhitespace();
                        if (token() !== 16) {
                            return undefined;
                        }
                        return parseJSDocTypeExpression();
                    });
                }
Inlined functions:
tryParse
(callback) {
            return 🔶speculationHelper(callback, false);
        }

createJSDocIdentifier:

(isIdentifier) {
                    if (!isIdentifier) {
                        🔶️parseErrorAtCurrentToken(ts⚠️.Diagnostics⚠️.Identifier_expected);
                        return undefined;
                    }
                    var pos = scanner.🔶getTokenPos();
                    var end = scanner.🔶getTextPos();
                    var result = 🔷createNode(70, pos);
                    result.text = content.🔶substring(pos, end);
                    🔷finishNode(result, end);
                    🔶nextJSDocToken();
                    return result;
                }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }

parseTagComments:

(indent) {
                    var comments = [];
                    var state = 1;
                    var margin;
                    🔶️function pushComment(text) {
                        if (!margin) {
                            margin = indent;
                        }
                        comments.push(text);
                        indent += text.length;
                    }
                    while (🔷token() !== 56 && 🔷token() !== 1) {
                        switch (🔷token()) {
                            case 4:
                                if (state >= 1) {
                                    state = 0;
                                    comments.push(scanner.🔶getTokenText());
                                }
                                indent = 0;
                                break;
                            case 56:
                                break;
                            case 5:
                                if (state === 2) {
                                    🔶pushComment(scanner.🔶getTokenText());
                                }
                                else {
                                    var whitespace = scanner.getTokenText();
                                    if (margin !== undefined && indent + whitespace.length > margin) {
                                        comments.⚠️push(whitespace.⚠️slice(margin ⚠️- indent - 1));
                                    }
                                    indent += whitespace.length;
                                }
                                break;
                            case 38:
                                if (state === 0) {
                                    state = 1;
                                    indent += scanner.🔶getTokenText().length;
                                    break;
                                }
                            default:
                                state = 2;
                                🔶pushComment(scanner.🔶getTokenText());
                                break;
                        }
                        if (🔷token() === 56) {
                            break;
                        }
                        🔶nextJSDocToken();
                    }
                    🔶️removeLeadingNewlines(comments);
                    🔶removeTrailingNewlines(comments);
                    return comments;
                }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

addTag:

(tag, comments) {
                    tag.comment = comments.🔶join("");
                    if (!tags) {
                        tags = 🔷createNodeArray([tag], tag.pos);
                    }
                    else {
                        tags.push(tag);
                    }
                    tags.end = tag.end;
                }
Inlined functions:
createNodeArray
(elements, pos) {
            var array = (elements || []);
            if (!(pos >= 0)) {
                pos = 🔷getNodePos();
            }
            array.pos ⚠️= pos;
            array.end = pos;
            return array;
        }
Inlined functions:
getNodePos
() {
            return scanner.🔶getStartPos();
        }

parseTag:

(indent) {
                    ts.Debug.🔶️assert(🔷token() === 56);
                    var atToken = 🔷createNode(56, scanner.🔶getTokenPos());
                    atToken.end = scanner.🔶getTextPos();
                    🔶nextJSDocToken();
                    var tagName = parseJSDocIdentifierName();
                    🔶skipWhitespace();
                    if (!tagName) {
                        return;
                    }
                    var tag;
                    if (tagName) {
                        switch (tagName.text) {
                            case "augments":
                                tag = 🔶️parseAugmentsTag(atToken, tagName);
                                break;
                            case "param":
                                tag = 🔶parseParamTag(atToken, tagName);
                                break;
                            case "return":
                            case "returns":
                                tag = 🔶️parseReturnTag(atToken, tagName);
                                break;
                            case "template":
                                tag = 🔶️parseTemplateTag(atToken, tagName);
                                break;
                            case "type":
                                tag = 🔶️parseTypeTag(atToken, tagName);
                                break;
                            case "typedef":
                                tag = 🔶️parseTypedefTag(atToken, tagName);
                                break;
                            default:
                                tag = 🔶️parseUnknownTag(atToken, tagName);
                                break;
                        }
                    }
                    else {
                        tag = 🔶️parseUnknownTag(atToken, tagName);
                    }
                    if (!tag) {
                        return;
                    }
                    🔶addTag(tag, 🔶parseTagComments(indent + tag.end - tag.pos));
                }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

resolveTypeReferenceDirectiveNamesWorker:

(typeReferenceDirectiveNames, containingFile) { return 🔷loadWithLocalCache(typeReferenceDirectiveNames, containingFile, loader_2); }
Inlined functions:
loadWithLocalCache
(names, containingFile, loader) {
        if (names.length === 0) {
            return [];
        }
        var resolutions = [];
        var cache = ts.🔷createMap();
        for (var _i = 0, names_1 = names; _i < names_1.length; _i++) {
            var name_42 = names_1[_i];
            var result = name_42 🔶️in cache
                ? cache⚠️[name_42]
                : cache[name_42] ⚠️= loader(name_42, containingFile);
            resolutions.push(result);
        }
        return resolutions;
    }
Inlined functions:
createMap
(template) {
        var map = createObject(null);
        map["__"] = undefined;
        🔶️delete map["__"];
        🔶️for (var key in template)
            if (hasOwnProperty.🔶️call(template, key)) {
                map[key] ⚠️= template⚠️[key];
            }
        return map;
    }

processReferencedFiles:

(file, isDefaultLib) {
            ts.🔷forEach(file.referencedFiles, 🔶️function (ref) {
                var referencedFileName = resolveTripleslashReference(ref.fileName, file.fileName);
                processSourceFile(referencedFileName, isDefaultLib, file, ref.pos, ref.end);
            });
        }
Inlined functions:
forEach
(array, callback) {
        if (array) {
            for (var i = 0, len = array.length; i < len; i++) {
                var result = 🔶️callback(array[i], i);
                if (result) {
                    return result;
                }
            }
        }
        return undefined;
    }

isWatchSet:

(options) {
        return options.watch && options.🔶️hasOwnProperty("watch");
    }

watchFile:

(fileName, callback, pollingInterval) {
                    if (useNonPollingWatchers) {
                        var watchedFile_1 = watchedFileSet.🔶️addFile(fileName, callback);
                        return ⚠️{
                            close: 🔶️function () { return watchedFileSet.removeFile(watchedFile_1); }
                        };
                    }
                    else {
                        _fs.🔶watchFile(fileName, { persistent: true, interval: pollingInterval || 250 }, fileChanged);
                        return {
                            close: 🔶️function () { return _fs.unwatchFile(fileName, fileChanged); }
                        };
                    }
                    🔶️function fileChanged(curr, prev) {
                        if (+curr.mtime <= +prev.mtime) {
                            return;
                        }
                        callback(fileName);
                    }
                }

useCaseSensitiveFileNames:

() { return ts.sys.useCaseSensitiveFileNames; }

getSourceFile:

~recompile~
~recompile~
~recompile~
(fileName, languageVersion, onError) {
            if (cachedProgram) {
                var sourceFile_1 = cachedProgram.🔶getSourceFile(fileName);
                if (sourceFile_1 && sourceFile_1⚠️.fileWatcher) {
                    return sourceFile_1;
                }
            }
            var sourceFile = 🔶️hostGetSourceFile(fileName, languageVersion, onError);
            if (sourceFile && ts.🔷isWatchSet(compilerOptions) && ts.sys.watchFile) {
                sourceFile.fileWatcher = ts.sys.🔶watchFile(sourceFile.fileName, 🔶️function (_fileName, removed) { return sourceFileChanged(sourceFile, removed); });
            }
            return sourceFile;
        }
Inlined functions:
isWatchSet
(options) {
        return options.watch && options.🔶️hasOwnProperty("watch");
    }

createSourceFile:

~recompile~
~recompile~
(fileName, languageVersion, scriptKind) {
            var sourceFile = 🔷new SourceFileConstructor(261, 0, sourceText.length);
            nodeCount++;
            sourceFile.text = sourceText;
            sourceFile.bindDiagnostics = [];
            sourceFile.languageVersion = languageVersion;
            sourceFile.fileName = ts.🔷normalizePath(fileName);
            sourceFile.languageVariant = 🔷getLanguageVariant(scriptKind);
            sourceFile.isDeclarationFile = ts.🔷fileExtensionIs(sourceFile.fileName, ".d.ts");
            sourceFile.scriptKind = scriptKind;
            return sourceFile;
        }
Inlined functions:
new SourceFileConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
normalizePath
(path) {
        path = 🔷normalizeSlashes(path);
        var rootLength = 🔶getRootLength(path);
        var root = path.🔶substr(0, rootLength);
        var normalized = 🔶getNormalizedParts(path, rootLength);
        if (normalized.length) {
            var joinedParts = root + normalized.🔶join(ts.directorySeparator);
            return 🔷pathEndsWithDirectorySeparator(path) ? joinedParts ⚠️+ ts⚠️.directorySeparator : joinedParts;
        }
        else {
            return root;
        }
    }
Inlined functions:
normalizeSlashes
(path) {
        return path.⚠️replace(🔶️/\x5c\x5c/g, "/");
    }
pathEndsWithDirectorySeparator
(path) {
        return path.charCodeAt(path.length - 1) === directorySeparatorCharCode;
    }
getLanguageVariant
(scriptKind) {
            return scriptKind === 4 || scriptKind === 2 || scriptKind === 1 ? 1 : 0;
        }
fileExtensionIs
(path, extension) {
        return path.length > extension.length && 🔷endsWith(path, extension);
    }
Inlined functions:
endsWith
(str, suffix) {
        var expectedPos = str.length - suffix.length;
        return expectedPos >= 0 && str.🔶indexOf(suffix, expectedPos) === expectedPos;
    }

getNodeConstructor:

() { return Node; }

getTokenConstructor:

() { return Node; }

getIdentifierConstructor:

() { return Node; }

getSourceFileConstructor:

() { return Node; }

setScriptTarget:

(scriptTarget) {
            languageVersion = scriptTarget;
        }

setLanguageVariant:

(variant) {
            languageVariant = variant;
        }

parseParamTag:

(atToken, tagName) {
                    var typeExpression = 🔶tryParseTypeExpression();
                    🔶skipWhitespace();
                    var name;
                    var isBracketed;
                    if (🔷parseOptionalToken(20)) {
                        name = 🔶parseJSDocIdentifierName();
                        🔶skipWhitespace();
                        isBracketed = true;
                        if (🔶parseOptionalToken(57)) {
                            🔶️parseExpression();
                        }
                        🔶parseExpected(21);
                    }
                    else if (ts.🔷tokenIsIdentifierOrKeyword(🔷token())) {
                        name = 🔶parseJSDocIdentifierName();
                    }
                    if (!name) {
                        🔶️parseErrorAtPosition(scanner.⚠️getStartPos(), 0, ts⚠️.Diagnostics⚠️.Identifier_expected);
                        return undefined;
                    }
                    var preName, postName;
                    if (typeExpression) {
                        postName = name;
                    }
                    else {
                        preName = name;
                    }
                    if (!typeExpression) {
                        typeExpression = 🔶tryParseTypeExpression();
                    }
                    var result = 🔷createNode(281, atToken.pos);
                    result.atToken = atToken;
                    result.tagName = tagName;
                    result.preParameterName = preName;
                    result.typeExpression = typeExpression;
                    result.postParameterName = postName;
                    result.parameterName = postName || preName;
                    result.isBracketed = isBracketed;
                    return 🔶finishNode(result);
                }
Inlined functions:
parseOptionalToken
(t) {
            if (🔷token() === t) {
                return 🔷parseTokenNode();
            }
            return undefined;
        }
Inlined functions:
token
() {
            return currentToken;
        }
parseTokenNode
() {
            var node = 🔷createNode(🔷token());
            🔷nextToken();
            return 🔷finishNode(node);
        }
Inlined functions:
token
() {
            return currentToken;
        }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }
token
() {
            return currentToken;
        }
tokenIsIdentifierOrKeyword
(token) {
        return token >= 70;
    }
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔶️new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

parseTypeAliasDeclaration:

(fullStart, decorators, modifiers) {
            var node = 🔷createNode(228, fullStart);
            node.decorators = decorators;
            node.modifiers = modifiers;
            🔷parseExpected(136);
            node.name = 🔷parseIdentifier();
            node.typeParameters = 🔶parseTypeParameters();
            🔶parseExpected(57);
            node.type = 🔶parseType();
            🔶parseSemicolon();
            return 🔶addJSDocComment(🔶finishNode(node));
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
parseIdentifier
(diagnosticMessage) {
            return 🔷createIdentifier(🔷isIdentifier(), diagnosticMessage);
        }
Inlined functions:
isIdentifier
() {
            if (🔷token() === 70) {
                return true;
            }
            if (🔷token() === 115 && 🔶inYieldContext()) {
                return false;
            }
            if (🔷token() === 120 && 🔶inAwaitContext()) {
                return false;
            }
            return 🔷token() > 106;
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
createIdentifier
(isIdentifier, diagnosticMessage) {
            identifierCount++;
            if (isIdentifier) {
                var node = 🔷createNode(70);
                if (🔶token() !== 70) {
                    node.originalKeywordKind = 🔶token();
                }
                node.text = 🔶️internIdentifier(scanner.🔶getTokenValue());
                🔶nextToken();
                return 🔶finishNode(node);
            }
            return 🔶️createMissingNode(70, false, diagnosticMessage || ts.Diagnostics.Identifier_expected);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔶️new IdentifierConstructor(kind, pos, pos) :
                    🔶️new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }

skipWhitespace:

() {
                    while (🔷token() === 5 || 🔷token() === 4) {
                        🔶nextJSDocToken();
                    }
                }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

removeTrailingNewlines:

(comments) {
                    while (comments.length && (comments[comments.length - 1] === "\x5cn" || comments[comments.length - 1] === "\x5cr")) {
                        comments.pop();
                    }
                }

setExternalModuleIndicator:

(sourceFile) {
            sourceFile.externalModuleIndicator ⚠️= ts.🔷forEach(sourceFile.statements, 🔶️function (node) {
                return ts.hasModifier(node, 1)
                    || node.kind === 234 && node.moduleReference.kind === 245
                    || node.kind === 235
                    || node.kind === 240
                    || node.kind === 241
                    ? node
                    : undefined;
            });
        }
Inlined functions:
forEach
(array, callback) {
        if (array) {
            for (var i = 0, len = array.length; i < len; i++) {
                var result = 🔶️callback(array[i], i);
                if (result) {
                    return result;
                }
            }
        }
        return undefined;
    }

isSourceFileJavaScript:

~recompile~
~recompile~
(file) {
        return 🔷isInJavaScriptFile(file);
    }
Inlined functions:
isInJavaScriptFile
(node) {
        return node && !!(node⚠️.flags & 65536);
    }

isExternalModule:

(file) {
        return file.externalModuleIndicator !== undefined;
    }

isDeclarationFile:

(file) {
        return file.isDeclarationFile;
    }

parseSignatureMember:

(kind) {
            var node = 🔷createNode(kind);
            if (kind === 154) {
                🔷parseExpected(93);
            }
            🔶fillSignature(55, false, false, false, node);
            🔷parseTypeMemberSemicolon();
            return 🔶addJSDocComment(🔶finishNode(node));
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
parseTypeMemberSemicolon
() {
            if (🔷parseOptional(25)) {
                return;
            }
            🔷parseSemicolon();
        }
Inlined functions:
parseOptional
(t) {
            if (🔷token() === t) {
                🔷nextToken();
                return true;
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
parseSemicolon
() {
            if (🔷canParseSemicolon()) {
                if (🔷token() === 24) {
                    🔶nextToken();
                }
                return true;
            }
            else {
                return 🔶parseExpected(24);
            }
        }
Inlined functions:
canParseSemicolon
() {
            if (🔷token() === 24) {
                return true;
            }
            return 🔷token() === 17 || 🔷token() === 1 || scanner.🔶hasPrecedingLineBreak();
        }
Inlined functions:
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

isStartOfConstructSignature:

() {
            🔷nextToken();
            return 🔷token() === 18 || 🔷token() === 26;
        }
Inlined functions:
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
token
() {
            return currentToken;
        }
token
() {
            return currentToken;
        }

parseTypeOperator:

(operator) {
            var node = 🔷createNode(168);
            🔷parseExpected(operator);
            node.operator = operator;
            node.type = 🔷parseTypeOperatorOrHigher();
            return 🔷finishNode(node);
        }
Inlined functions:
createNode
(kind, pos) {
            nodeCount++;
            if (!(pos ⚠️>= 0)) {
                pos = scanner.🔶getStartPos();
            }
            return kind >= 141 ? 🔷new NodeConstructor(kind, pos, pos) :
                kind === 70 ? 🔷new IdentifierConstructor(kind, pos, pos) :
                    🔷new TokenConstructor(kind, pos, pos);
        }
Inlined functions:
new NodeConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new IdentifierConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
new TokenConstructor
(kind, pos, end) {
        this.id = 0;
        this.kind = kind;
        this.pos = pos;
        this.end = end;
        this.flags = 0;
        this.modifierFlagsCache = 0;
        this.transformFlags = 0;
        this.parent = undefined;
        this.original = undefined;
    }
parseExpected
(kind, diagnosticMessage, shouldAdvance) {
            if (shouldAdvance === void 0) { shouldAdvance = true; }
            if (🔷token() === kind) {
                if (shouldAdvance) {
                    🔷nextToken();
                }
                return true;
            }
            if (diagnosticMessage) {
                🔶️parseErrorAtCurrentToken(diagnosticMessage);
            }
            else {
                🔷parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.🔷tokenToString(kind));
            }
            return false;
        }
Inlined functions:
token
() {
            return currentToken;
        }
nextToken
() {
            return currentToken = scanner.🔶scan();
        }
tokenToString
(t) {
        return tokenStrings[t];
    }
parseErrorAtCurrentToken
(message, arg0) {
            var start = scanner.🔶getTokenPos();
            var length = scanner.🔶getTextPos() - start;
            🔷parseErrorAtPosition(start, length, message, arg0);
        }
Inlined functions:
parseErrorAtPosition
(start, length, message, arg0) {
            var lastError = ts.🔷lastOrUndefined(parseDiagnostics);
            if (!lastError || start !== lastError.start) {
                parseDiagnostics.push(ts.🔶️createFileDiagnostic(sourceFile, start, length, message, arg0));
            }
            parseErrorBeforeNextFinishedNode = true;
        }
Inlined functions:
lastOrUndefined
(array) {
        return array && array.length > 0
            ? array[array.length - 1]
            : undefined;
    }
parseTypeOperatorOrHigher
() {
            switch (🔷token()) {
                case 126:
                    return 🔶parseTypeOperator(126);
            }
            return 🔶parseArrayTypeOrHigher();
        }
Inlined functions:
token
() {
            return currentToken;
        }
finishNode
(node, end) {
            node.end ⚠️= end === undefined ? scanner.🔶getStartPos() : end;
            if (contextFlags) {
                node.flags ⚠️|= contextFlags;
            }
            if (parseErrorBeforeNextFinishedNode) {
                parseErrorBeforeNextFinishedNode = false;
                node.flags ⚠️|= 32768;
            }
            return node;
        }

collectModuleReferences:

(node, inAmbientModule) {
                switch (node⚠️.kind) {
                    case 235:
                    case 234:
                    case 241:
                        var moduleNameExpr = ts.🔷getExternalModuleName(node);
                        if (!moduleNameExpr || moduleNameExpr.kind !== 9) {
                            break;
                        }
                        if (!moduleNameExpr.text) {
                            break;
                        }
                        if (!inAmbientModule || !ts.🔷isExternalModuleNameRelative(moduleNameExpr.text)) {
                            (imports || (imports = [])).push(moduleNameExpr);
                        }
                        break;
                    case 230:
                        if (ts.🔷isAmbientModule(node) && (inAmbientModule || ts.🔷hasModifier(node, 2) || ts.⚠️isDeclarationFile(file))) {
                            var moduleName = node.name;
                            if (isExternalModuleFile || (inAmbientModule && !ts.🔶isExternalModuleNameRelative(moduleName⚠️.text))) {
                                (moduleAugmentations || (moduleAugmentations = 🔶️[])).🔶️push(moduleName);
                            }
                            else if (!inAmbientModule) {
                                if (isDtsFile) {
                                    (ambientModules || (ambientModules = [])).push(moduleName.text);
                                }
                                var body = node.body;
                                if (body) {
                                    for (var _i = 0, _a = body.statements; _i < _a.length; _i++) {
                                        var statement = _a[_i];
                                        🔶collectModuleReferences(statement, true);
                                    }
                                }
                            }
                        }
                }
            }
Inlined functions:
getExternalModuleName
(node) {
        if (node⚠️.kind === 235) {
            return node.moduleSpecifier;
        }
        if (node.kind === 234) {
            var reference = node.moduleReference;
            if (reference.kind === 245) {
                return reference.expression;
            }
        }
        if (node.kind === 241) {
            return node.moduleSpecifier;
        }
        if (node⚠️.kind ⚠️=== 230 && node⚠️.name⚠️.kind ⚠️=== 9) {
            return node⚠️.name;
        }
    }
isExternalModuleNameRelative
(moduleName) {
        return 🔶️/^\x5c.\x5c.?($|[\🔶️x5c\x5c/])/.test(moduleName);
    }
isAmbientModule
(node) {
        return node && node.kind === 230 &&
            (node.name.kind === 9 || 🔷isGlobalScopeAugmentation(node));
    }
Inlined functions:
isGlobalScopeAugmentation
(module) {
        return !!(module.flags & 512);
    }
hasModifier
(node, flags) {
        return (🔷getModifierFlags(node) & flags) !== 0;
    }
Inlined functions:
getModifierFlags
(node) {
        if (node⚠️.modifierFlagsCache & 536870912) {
            return node⚠️.modifierFlagsCache & ~536870912;
        }
        var flags = 0;
        if (node⚠️.modifiers) {
            for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
                var modifier = _a[_i];
                flags |= 🔷modifierToFlag(modifier.kind);
            }
        }
        if (node⚠️.flags & 4 || (node⚠️.kind === 70 && node⚠️.isInJSDocNamespace)) {
            flags |⚠️= 1;
        }
        node.modifierFlagsCache ⚠️= flags | 536870912;
        return flags;
    }
Inlined functions:
modifierToFlag
(token) {
        switch (token) {
            case 114: return 32;
            case 113: return 4;
            case 112: return 16;
            case 111: return 8;
            case 116: return 128;
            case 83: return 1;
            case 123: return 2;
            case 75: return 2048;
            case 78: return 512;
            case 119: return 256;
            case 130: return 64;
        }
        return 0;
    }

shouldEmitInDirectory:

~recompile~
~recompile~
(sourceFile, isSourceFileFromExternalLibrary) {
        return 🔷isNonDeclarationFile(sourceFile) && !🔶️isSourceFileFromExternalLibrary(sourceFile);
    }
Inlined functions:
isNonDeclarationFile
(sourceFile) {
        return !🔷isDeclarationFile(sourceFile);
    }
Inlined functions:
isDeclarationFile
(file) {
        return file⚠️.isDeclarationFile;
    }

isNonDeclarationFile:

(sourceFile) {
        return !🔷isDeclarationFile(sourceFile);
    }
Inlined functions:
isDeclarationFile
(file) {
        return file⚠️.isDeclarationFile;
    }

isInJavaScriptFile:

~recompile~
~recompile~
(node) {
        return node && !!(node⚠️.flags & 65536);
    }

visitNodeArray:

(cbNodes, nodes) {
        if (nodes) {
            return 🔶️cbNodes(nodes);
        }
    }

isAmbientModule:

~recompile~
~recompile~
~recompile~
(node) {
        return node && node⚠️.kind === 230 &&
            (node⚠️.name.kind === 9 || 🔷isGlobalScopeAugmentation(node));
    }
Inlined functions:
isGlobalScopeAugmentation
(module) {
        return !!(module⚠️.flags & 512);
    }

hasDynamicName:

~recompile~
~recompile~
(declaration) {
        return declaration.name && 🔷isDynamicName(declaration.name);
    }
Inlined functions:
isDynamicName
(name) {
        return name.kind === 142 &&
            !🔶isStringOrNumericLiteral(name⚠️.expression) &&
            !🔶isWellKnownSymbolSyntactically(name⚠️.expression);
    }

bindEachChild:

(node) {
            ts.🔶forEachChild(node, bind, bindEach);
        }

bind:

~recompile~
~recompile~
(node) {
            if (!node) {
                return;
            }
            node.parent ⚠️= parent;
            var saveInStrictMode = inStrictMode;
            🔶bindWorker(node);
            if (node⚠️.kind > 140) {
                var saveParent = parent;
                parent = node;
                var containerFlags = 🔶getContainerFlags(node);
                if (containerFlags === 0) {
                    🔶bindChildren(node);
                }
                else {
                    🔶bindContainer(node, containerFlags);
                }
                parent = saveParent;
            }
            else if (!skipTransformFlagAggregation && (node⚠️.transformFlags & 536870912) === 0) {
                subtreeTransformFlags |= 🔶computeTransformFlagsForNode(node, 0);
            }
            inStrictMode = saveInStrictMode;
        }

isExpression:

~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
(node) {
        return 🔷isExpressionKind(ts.🔷skipPartiallyEmittedExpressions(node)⚠️.kind);
    }
Inlined functions:
skipPartiallyEmittedExpressions
(node) {
        while (node⚠️.kind === 294) {
            node = node.expression;
        }
        return node;
    }
isExpressionKind
(kind) {
        return kind === 193
            || kind === 195
            || kind === 185
            || kind === 192
            || kind === 196
            || kind === 200
            || kind === 198
            || kind === 297
            || 🔷isUnaryExpressionKind(kind);
    }
Inlined functions:
isUnaryExpressionKind
(kind) {
        return kind === 190
            || kind === 191
            || kind === 186
            || kind === 187
            || kind === 188
            || kind === 189
            || kind === 182
            || 🔶isLeftHandSideExpressionKind(kind);
    }

Symbol:

(flags, name) {
        this.flags = flags;
        this.name = name;
        this.declarations = undefined;
    }

createSymbol:

~recompile~
~recompile~
(flags, name) {
            symbolCount++;
            return 🔷new Symbol(flags, name);
        }
Inlined functions:
new Symbol
(flags, name) {
        this.flags = flags;
        this.name = name;
        this.declarations = undefined;
    }

⛔ isDynamicName (deoptimizated):

~recompile~
- Deopt: <JS Function isExpression (SharedFunctionInfo 0x30d407feb261)> (opt #461) @7, FP to SP delta: 56, caller sp: 0x7fff5fbfd648
~recompile~
~recompile~
~recompile~
(name) {
        return name⚠️.kind === 142 &&
            !🔷isStringOrNumericLiteral(name.expression) &&
            !🔷isWellKnownSymbolSyntactically(name.expression);
    }
Inlined functions:
isStringOrNumericLiteral
(node) {
        var kind = node.kind;
        return kind === 9
            || kind === 8;
    }
isWellKnownSymbolSyntactically
(node) {
        return 🔷isPropertyAccessExpression(node) && 🔷isESSymbolIdentifier(node.expression);
    }
Inlined functions:
isPropertyAccessExpression
(node) {
        return node⚠️.kind === 177;
    }
isESSymbolIdentifier
(node) {
        return node.kind === 70 && node.text === "Symbol";
    }

isExpressionKind:

(kind) {
        return kind === 193
            || kind === 195
            || kind === 185
            || kind === 192
            || kind === 196
            || kind === 200
            || kind === 198
            || kind === 297
            || 🔷isUnaryExpressionKind(kind);
    }
Inlined functions:
isUnaryExpressionKind
(kind) {
        return kind === 190
            || kind === 191
            || kind === 186
            || kind === 187
            || kind === 188
            || kind === 189
            || kind === 182
            || 🔶isLeftHandSideExpressionKind(kind);
    }

bindPropertyOrMethodOrAccessor:

~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
(node, symbolFlags, symbolExcludes) {
            if (!ts.🔷isDeclarationFile(file) && !ts.🔷isInAmbientContext(node)) {
                if (ts.🔷isAsyncFunctionLike(node)) {
                    emitFlags |⚠️= 1024;
                }
            }
            if (currentFlow && ts.🔶isObjectLiteralOrClassExpressionMethod(node)) {
                node.flowNode ⚠️= currentFlow;
            }
            return ts.🔶hasDynamicName(node)
                ? 🔶bindAnonymousDeclaration(node, symbolFlags, "__computed")
                : 🔶declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
        }
Inlined functions:
isDeclarationFile
(file) {
        return file⚠️.isDeclarationFile;
    }
isInAmbientContext
(node) {
        while (node) {
            if (🔷hasModifier(node, 2) || (node⚠️.kind === 261 && node.isDeclarationFile)) {
                return true;
            }
            node = node⚠️.parent;
        }
        return false;
    }
Inlined functions:
hasModifier
(node, flags) {
        return (🔷getModifierFlags(node) & flags) !== 0;
    }
Inlined functions:
getModifierFlags
(node) {
        if (node⚠️.modifierFlagsCache & 536870912) {
            return node⚠️.modifierFlagsCache & ~536870912;
        }
        var flags = 0;
        if (node⚠️.modifiers) {
            for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
                var modifier = _a[_i];
                flags |= 🔷modifierToFlag(modifier.kind);
            }
        }
        if (node⚠️.flags & 4 || (node⚠️.kind === 70 && node⚠️.isInJSDocNamespace)) {
            flags |⚠️= 1;
        }
        node.modifierFlagsCache ⚠️= flags | 536870912;
        return flags;
    }
Inlined functions:
modifierToFlag
(token) {
        switch (token) {
            case 114: return 32;
            case 113: return 4;
            case 112: return 16;
            case 111: return 8;
            case 116: return 128;
            case 83: return 1;
            case 123: return 2;
            case 75: return 2048;
            case 78: return 512;
            case 119: return 256;
            case 130: return 64;
        }
        return 0;
    }
isAsyncFunctionLike
(node) {
        return 🔷isFunctionLike(node) && 🔷hasModifier(node, 256) && !🔶️isAccessor(node);
    }
Inlined functions:
isFunctionLike
(node) {
        return node && 🔷isFunctionLikeKind(node⚠️.kind);
    }
Inlined functions:
isFunctionLikeKind
(kind) {
        switch (kind) {
            case 150:
            case 184:
            case 225:
            case 185:
            case 149:
            case 148:
            case 151:
            case 152:
            case 153:
            case 154:
            case 155:
            case 158:
            case 159:
                return true;
        }
        return false;
    }
hasModifier
(node, flags) {
        return (🔷getModifierFlags(node) & flags) !== 0;
    }
Inlined functions:
getModifierFlags
(node) {
        if (node⚠️.modifierFlagsCache & 536870912) {
            return node⚠️.modifierFlagsCache & ~536870912;
        }
        var flags = 0;
        if (node⚠️.modifiers) {
            for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
                var modifier = _a[_i];
                flags |= 🔷modifierToFlag(modifier.kind);
            }
        }
        if (node⚠️.flags & 4 || (node⚠️.kind === 70 && node⚠️.isInJSDocNamespace)) {
            flags |⚠️= 1;
        }
        node.modifierFlagsCache ⚠️= flags | 536870912;
        return flags;
    }
Inlined functions:
modifierToFlag
(token) {
        switch (token) {
            case 114: return 32;
            case 113: return 4;
            case 112: return 16;
            case 111: return 8;
            case 116: return 128;
            case 83: return 1;
            case 123: return 2;
            case 75: return 2048;
            case 78: return 512;
            case 119: return 256;
            case 130: return 64;
        }
        return 0;
    }

bindWorker:

~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
(node) {
            switch (node⚠️.kind) {
                case 70:
                    if (node.isInJSDocNamespace) {
                        var parentNode = node⚠️.parent;
                        while (parentNode && parentNode⚠️.kind ⚠️!== 285) {
                            parentNode = parentNode⚠️.parent;
                        }
                        🔶bindBlockScopedDeclaration(parentNode, 524288, 793064);
                        break;
                    }
                case 98:
                    if (currentFlow && (ts.🔷isExpression(node) || parent⚠️.kind ⚠️=== 258)) {
                        node.flowNode = currentFlow;
                    }
                    return 🔷checkStrictModeIdentifier(node);
                case 177:
                    if (currentFlow && 🔷isNarrowableReference(node)) {
                        node.flowNode = currentFlow;
                    }
                    break;
                case 192:
                    if (ts.🔷isInJavaScriptFile(node)) {
                        var specialKind = ts.🔶️getSpecialPropertyAssignmentKind(node);
                        ⚠️switch (specialKind) {
                            case 1:
                                🔶️bindExportsPropertyAssignment(node);
                                break;
                            case 2:
                                🔶️bindModuleExportsAssignment(node);
                                break;
                            case 3:
                                🔶️bindPrototypePropertyAssignment(node);
                                break;
                            case 4:
                                🔶️bindThisPropertyAssignment(node);
                                break;
                            case 0:
                                break;
                            default:
                                ts⚠️.Debug.🔶️fail("Unknown special property assignment kind");
                        }
                    }
                    return 🔷checkStrictModeBinaryExpression(node);
                case 256:
                    return 🔷checkStrictModeCatchClause(node);
                case 186:
                    return 🔶️checkStrictModeDeleteExpression(node);
                case 8:
                    return 🔶️checkStrictModeNumericLiteral(node);
                case 191:
                    return 🔶️checkStrictModePostfixUnaryExpression(node);
                case 190:
                    return 🔶️checkStrictModePrefixUnaryExpression(node);
                case 217:
                    return 🔶️checkStrictModeWithStatement(node);
                case 167:
                    seenThisKeyword = true;
                    return;
                case 156:
                    return 🔶checkTypePredicate(node);
                case 143:
                    return 🔶declareSymbolAndAddToSymbolTable(node, 262144, 530920);
                case 144:
                    return 🔶bindParameter(node);
                case 223:
                case 174:
                    return 🔶bindVariableDeclarationOrBindingElement(node);
                case 147:
                case 146:
                case 271:
                    return 🔶bindPropertyOrMethodOrAccessor(node, 4 | (node.questionToken ? 536870912 : 0), 0);
                case 286:
                    return 🔶️bindJSDocProperty(node);
                case 257:
                case 258:
                    return 🔶bindPropertyOrMethodOrAccessor(node, 4, 0);
                case 260:
                    return 🔶bindPropertyOrMethodOrAccessor(node, 8, 900095);
                case 259:
                case 251:
                    var root = container;
                    var hasRest = false;
                    while (root.parent) {
                        if (root.kind === 176 &&
                            root⚠️.parent⚠️.kind ⚠️=== 192 &&
                            root⚠️.parent⚠️.operatorToken⚠️.kind ⚠️=== 57 &&
                            root⚠️.parent⚠️.left ⚠️=== root) {
                            hasRest = true;
                            break;
                        }
                        root = root.parent;
                    }
                    return;
                case 153:
                case 154:
                case 155:
                    return 🔶declareSymbolAndAddToSymbolTable(node, 131072, 0);
                case 149:
                case 148:
                    return 🔶bindPropertyOrMethodOrAccessor(node, 8192 | (node⚠️.questionToken ? 536870912 : 0), ts.🔶isObjectLiteralMethod(node) ? 0 : 99263);
                case 225:
                    return 🔶bindFunctionDeclaration(node);
                case 150:
                    return 🔶declareSymbolAndAddToSymbolTable(node, 16384, 0);
                case 151:
                    return 🔶bindPropertyOrMethodOrAccessor(node, 32768, 41919);
                case 152:
                    return 🔶bindPropertyOrMethodOrAccessor(node, 65536, 74687);
                case 158:
                case 159:
                case 274:
                    return 🔶bindFunctionOrConstructorType(node);
                case 161:
                case 170:
                case 287:
                case 270:
                    return 🔶bindAnonymousDeclaration(node, 2048, "__type");
                case 176:
                    return 🔶️bindObjectLiteralExpression(node);
                case 184:
                case 185:
                    return 🔶bindFunctionExpression(node);
                case 179:
                    if (ts.🔶isInJavaScriptFile(node)) {
                        🔶️bindCallExpression(node);
                    }
                    break;
                case 197:
                case 226:
                    inStrictMode = true;
                    return 🔶️bindClassLikeDeclaration(node);
                case 227:
                    return 🔶bindBlockScopedDeclaration(node, 64, 792968);
                case 285:
                    if (!node⚠️.fullName || node⚠️.fullName⚠️.kind ⚠️=== 70) {
                        return 🔶bindBlockScopedDeclaration(node, 524288, 793064);
                    }
                    break;
                case 228:
                    return 🔶bindBlockScopedDeclaration(node, 524288, 793064);
                case 229:
                    return 🔶️bindEnumDeclaration(node);
                case 230:
                    return 🔶️bindModuleDeclaration(node);
                case 234:
                case 237:
                case 239:
                case 243:
                    return 🔶declareSymbolAndAddToSymbolTable(node, 8388608, 8388608);
                case 233:
                    return 🔶️bindNamespaceExportDeclaration(node);
                case 236:
                    return 🔶bindImportClause(node);
                case 241:
                    return 🔶️bindExportDeclaration(node);
                case 240:
                    return 🔶️bindExportAssignment(node);
                case 261:
                    🔶️updateStrictModeStatementList(node.statements);
                    return 🔶bindSourceFileIfExternalModule();
                case 204:
                    if (!ts.🔶isFunctionLike(node.parent)) {
                        return;
                    }
                case 231:
                    return 🔶️updateStrictModeStatementList(node.statements);
            }
        }
Inlined functions:
isExpression
(node) {
        return 🔷isExpressionKind(ts.🔷skipPartiallyEmittedExpressions(node).kind);
    }
Inlined functions:
skipPartiallyEmittedExpressions
(node) {
        while (node⚠️.kind === 294) {
            node = node⚠️.expression;
        }
        return node;
    }
isExpressionKind
(kind) {
        return kind === 193
            || kind === 195
            || kind === 185
            || kind === 192
            || kind === 196
            || kind === 200
            || kind === 198
            || kind === 297
            || 🔷isUnaryExpressionKind(kind);
    }
Inlined functions:
isUnaryExpressionKind
(kind) {
        return kind === 190
            || kind === 191
            || kind === 186
            || kind === 187
            || kind === 188
            || kind === 189
            || kind === 182
            || 🔶isLeftHandSideExpressionKind(kind);
    }
checkStrictModeIdentifier
(node) {
            if (inStrictMode &&
                node.originalKeywordKind >= 107 &&
                node.originalKeywordKind <= 115 &&
                !ts.🔶️isIdentifierName(node) &&
                !ts.🔶️isInAmbientContext(node)) {
                if (!file⚠️.parseDiagnostics⚠️.length) {
                    file⚠️.bindDiagnostics.🔶️push(ts.🔶️createDiagnosticForNode(node, 🔶️getStrictModeIdentifierMessage(node), ts.🔶️declarationNameToString(node)));
                }
            }
        }
isNarrowableReference
(expr) {
            return expr⚠️.kind === 70 ||
                expr⚠️.kind === 98 ||
                expr⚠️.kind === 177 && 🔶isNarrowableReference(expr.expression);
        }
isInJavaScriptFile
(node) {
        return node && !!(node⚠️.flags & 65536);
    }
checkStrictModeBinaryExpression
(node) {
            if (inStrictMode && ts.🔷isLeftHandSideExpression(node.left) && ts.🔷isAssignmentOperator(node.operatorToken.kind)) {
                🔷checkStrictModeEvalOrArguments(node, node.left);
            }
        }
Inlined functions:
isLeftHandSideExpression
(node) {
        return 🔶isLeftHandSideExpressionKind(ts.🔷skipPartiallyEmittedExpressions(node)⚠️.kind);
    }
Inlined functions:
skipPartiallyEmittedExpressions
(node) {
        while (node⚠️.kind === 294) {
            node = node⚠️.expression;
        }
        return node;
    }
isAssignmentOperator
(token) {
        return token >= 57 && token <= 69;
    }
checkStrictModeEvalOrArguments
(contextNode, name) {
            if (name && name⚠️.kind === 70) {
                var identifier = name;
                if (🔷isEvalOrArgumentsIdentifier(identifier)) {
                    var span_3 = ts.🔶️getErrorSpanForNode(file, name);
                    file⚠️.bindDiagnostics.🔶️push(ts.⚠️createFileDiagnostic(file, span_3⚠️.start, span_3⚠️.length, 🔶️getStrictModeEvalOrArgumentsMessage(contextNode), identifier⚠️.text));
                }
            }
        }
Inlined functions:
isEvalOrArgumentsIdentifier
(node) {
            return node.kind === 70 &&
                (node.text === "eval" || node.text === "arguments");
        }
checkStrictModeCatchClause
(node) {
            if (inStrictMode && node.variableDeclaration) {
                🔷checkStrictModeEvalOrArguments(node, node.variableDeclaration.name);
            }
        }
Inlined functions:
checkStrictModeEvalOrArguments
(contextNode, name) {
            if (name && name⚠️.kind === 70) {
                var identifier = name;
                if (🔷isEvalOrArgumentsIdentifier(identifier)) {
                    var span_3 = ts.🔶️getErrorSpanForNode(file, name);
                    file⚠️.bindDiagnostics.🔶️push(ts.⚠️createFileDiagnostic(file, span_3⚠️.start, span_3⚠️.length, 🔶️getStrictModeEvalOrArgumentsMessage(contextNode), identifier⚠️.text));
                }
            }
        }
Inlined functions:
isEvalOrArgumentsIdentifier
(node) {
            return node.kind === 70 &&
                (node.text === "eval" || node.text === "arguments");
        }

forEachChild:

~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
~recompile~
(node, cbNode, cbNodeArray) {
        if (!node) {
            return;
        }
        var visitNodes = cbNodeArray ? visitNodeArray : visitEachNode;
        var cbNodes = cbNodeArray || cbNode;
        switch (node⚠️.kind) {
            case 141:
                return 🔷visitNode(cbNode, node.left) ||
                    🔷visitNode(cbNode, node.right);
            case 143:
                return 🔷visitNode(cbNode, node.name) ||
                    🔷visitNode(cbNode, node.constraint) ||
                    🔷visitNode(cbNode, node.expression);
            case 258:
                return 🔷visitNodes(cbNodes, node⚠️.decorators) ||
                    🔷visitNodes(cbNodes, node⚠️.modifiers) ||
                    🔷visitNode(cbNode, node⚠️.name) ||
                    🔷visitNode(cbNode, node⚠️.questionToken) ||
                    🔷visitNode(cbNode, node⚠️.equalsToken) ||
                    🔷visitNode(cbNode, node⚠️.objectAssignmentInitializer);
            case 259:
                return 🔶visitNode(cbNode, node⚠️.expression);
            case 144:
            case 147:
            case 146:
            case 257:
            case 223:
            case 174:
                return 🔷visitNodes(cbNodes, node⚠️.decorators) ||
                    🔷visitNodes(cbNodes, node⚠️.modifiers) ||
                    🔷visitNode(cbNode, node⚠️.propertyName) ||
                    🔷visitNode(cbNode, node⚠️.dotDotDotToken) ||
                    🔷visitNode(cbNode, node⚠️.name) ||
                    🔷visitNode(cbNode, node⚠️.questionToken) ||
                    🔷visitNode(cbNode, node⚠️.type) ||
                    🔷visitNode(cbNode, node⚠️.initializer);
            case 158:
            case 159:
            case 153:
            case 154:
            case 155:
                return 🔷visitNodes(cbNodes, node.decorators) ||
                    🔷visitNodes(cbNodes, node.modifiers) ||
                    🔷visitNodes(cbNodes, node.typeParameters) ||
                    🔷visitNodes(cbNodes, node.parameters) ||
                    🔷visitNode(cbNode, node⚠️.type);
            case 149:
            case 148:
            case 150:
            case 151:
            case 152:
            case 184:
            case 225:
            case 185:
                return 🔷visitNodes(cbNodes, node⚠️.decorators) ||
                    🔷visitNodes(cbNodes, node⚠️.modifiers) ||
                    🔷visitNode(cbNode, node⚠️.asteriskToken) ||
                    🔷visitNode(cbNode, node⚠️.name) ||
                    🔷visitNode(cbNode, node⚠️.questionToken) ||
                    🔷visitNodes(cbNodes, node⚠️.typeParameters) ||
                    🔷visitNodes(cbNodes, node⚠️.parameters) ||
                    🔷visitNode(cbNode, node⚠️.type) ||
                    🔷visitNode(cbNode, node⚠️.equalsGreaterThanToken) ||
                    🔷visitNode(cbNode, node⚠️.body);
            case 157:
                return 🔷visitNode(cbNode, node.typeName) ||
                    🔷visitNodes(cbNodes, node.typeArguments);
            case 156:
                return 🔷visitNode(cbNode, node.parameterName) ||
                    🔷visitNode(cbNode, node.type);
            case 160:
                return 🔷visitNode(cbNode, node.exprName);
            case 161:
                return 🔷visitNodes(cbNodes, node.members);
            case 162:
                return 🔷visitNode(cbNode, node.elementType);
            case 163:
                return 🔷visitNodes(cbNodes, node.elementTypes);
            case 164:
            case 165:
                return 🔷visitNodes(cbNodes, node.types);
            case 166:
            case 168:
                return 🔷visitNode(cbNode, node.type);
            case 169:
                return 🔷visitNode(cbNode, node.objectType) ||
                    🔷visitNode(cbNode, node.indexType);
            case 170:
                return 🔷visitNode(cbNode, node.readonlyToken) ||
                    🔷visitNode(cbNode, node.typeParameter) ||
                    🔷visitNode(cbNode, node.questionToken) ||
                    🔷visitNode(cbNode, node.type);
            case 171:
                return 🔷visitNode(cbNode, node.literal);
            case 172:
            case 173:
                return 🔷visitNodes(cbNodes, node.elements);
            case 175:
                return 🔷visitNodes(cbNodes, node.elements);
            case 176:
                return 🔷visitNodes(cbNodes, node.properties);
            case 177:
                return 🔷visitNode(cbNode, node.expression) ||
                    🔷visitNode(cbNode, node.name);
            case 178:
                return 🔷visitNode(cbNode, node.expression) ||
                    🔷visitNode(cbNode, node.argumentExpression);
            case 179:
            case 180:
                return 🔶visitNode(cbNode, node.expression) ||
                    🔶visitNodes(cbNodes, node.typeArguments) ||
                    🔶visitNodes(cbNodes, node.arguments);
            case 181:
                return 🔶visitNode(cbNode, node⚠️.tag) ||
                    🔶visitNode(cbNode, node⚠️.template);
            case 182:
                return 🔶visitNode(cbNode, node⚠️.type) ||
                    🔶visitNode(cbNode, node⚠️.expression);
            case 183:
                return 🔶visitNode(cbNode, node.expression);
            case 186:
                return 🔶visitNode(cbNode, node⚠️.expression);
            case 187:
                return 🔶visitNode(cbNode, node.expression);
            case 188:
                return 🔶visitNode(cbNode, node⚠️.expression);
            case 190:
                return 🔶visitNode(cbNode, node.operand);
            case 195:
                return 🔶visitNode(cbNode, node⚠️.asteriskToken) ||
                    🔶visitNode(cbNode, node⚠️.expression);
            case 189:
                return 🔶visitNode(cbNode, node⚠️.expression);
            case 191:
                return 🔶visitNode(cbNode, node.operand);
            case 192:
                return 🔶visitNode(cbNode, node.left) ||
                    🔶visitNode(cbNode, node.operatorToken) ||
                    🔶visitNode(cbNode, node.right);
            case 200:
                return 🔶visitNode(cbNode, node.expression) ||
                    🔶visitNode(cbNode, node.type);
            case 201:
                return 🔶visitNode(cbNode, node.expression);
            case 193:
                return 🔶visitNode(cbNode, node⚠️.condition) ||
                    🔶visitNode(cbNode, node⚠️.questionToken) ||
                    🔶visitNode(cbNode, node⚠️.whenTrue) ||
                    🔶visitNode(cbNode, node⚠️.colonToken) ||
                    🔶visitNode(cbNode, node⚠️.whenFalse);
            case 196:
                return 🔶visitNode(cbNode, node⚠️.expression);
            case 204:
            case 231:
                return 🔶visitNodes(cbNodes, node.statements);
            case 261:
                return 🔶visitNodes(cbNodes, node.statements) ||
                    🔶visitNode(cbNode, node.endOfFileToken);
            case 205:
                return 🔶visitNodes(cbNodes, node.decorators) ||
                    🔶visitNodes(cbNodes, node.modifiers) ||
                    🔶visitNode(cbNode, node.declarationList);
            case 224:
                return 🔶visitNodes(cbNodes, node.declarations);
            case 207:
                return 🔶visitNode(cbNode, node.expression);
            case 208:
                return 🔶visitNode(cbNode, node⚠️.expression) ||
                    🔶visitNode(cbNode, node⚠️.thenStatement) ||
                    🔶visitNode(cbNode, node⚠️.elseStatement);
            case 209:
                return 🔶visitNode(cbNode, node⚠️.statement) ||
                    🔶visitNode(cbNode, node⚠️.expression);
            case 210:
                return 🔶visitNode(cbNode, node⚠️.expression) ||
                    🔶visitNode(cbNode, node⚠️.statement);
            case 211:
                return 🔶visitNode(cbNode, node⚠️.initializer) ||
                    🔶visitNode(cbNode, node⚠️.condition) ||
                    🔶visitNode(cbNode, node⚠️.incrementor) ||
                    🔶visitNode(cbNode, node⚠️.statement);
            case 212:
                return 🔶visitNode(cbNode, node⚠️.initializer) ||
                    🔶visitNode(cbNode, node⚠️.expression) ||
                    🔶visitNode(cbNode, node⚠️.statement);
            case 213:
                return 🔶visitNode(cbNode, node⚠️.initializer) ||
                    🔶visitNode(cbNode, node⚠️.expression) ||
                    🔶visitNode(cbNode, node⚠️.statement);
            case 214:
            case 215:
                return 🔶visitNode(cbNode, node⚠️.label);
            case 216:
                return 🔶visitNode(cbNode, node⚠️.expression);
            case 217:
                return 🔶visitNode(cbNode, node⚠️.expression) ||
                    🔶visitNode(cbNode, node⚠️.statement);
            case 218:
                return 🔶visitNode(cbNode, node⚠️.expression) ||
                    🔶visitNode(cbNode, node⚠️.caseBlock);
            case 232:
                return 🔶visitNodes(cbNodes, node⚠️.clauses);
            case 253:
                return 🔶visitNode(cbNode, node⚠️.expression) ||
                    🔶visitNodes(cbNodes, node⚠️.statements);
            case 254:
                return 🔶visitNodes(cbNodes, node⚠️.statements);
            case 219:
                return 🔶visitNode(cbNode, node⚠️.label) ||
                    🔶visitNode(cbNode, node⚠️.statement);
            case 220:
                return 🔶visitNode(cbNode, node⚠️.expression);
            case 221:
                return 🔶visitNode(cbNode, node⚠️.tryBlock) ||
                    🔶visitNode(cbNode, node⚠️.catchClause) ||
                    🔶visitNode(cbNode, node⚠️.finallyBlock);
            case 256:
                return 🔶visitNode(cbNode, node⚠️.variableDeclaration) ||
                    🔶visitNode(cbNode, node⚠️.block);
            case 145:
                return 🔶visitNode(cbNode, node.expression);
            case 226:
            case 197:
                return 🔶visitNodes(cbNodes, node.decorators) ||
                    🔶visitNodes(cbNodes, node.modifiers) ||
                    🔶visitNode(cbNode, node.name) ||
                    🔶visitNodes(cbNodes, node.typeParameters) ||
                    🔶visitNodes(cbNodes, node.heritageClauses) ||
                    🔶visitNodes(cbNodes, node.members);
            case 227:
                return 🔶visitNodes(cbNodes, node.decorators) ||
                    🔶visitNodes(cbNodes, node.modifiers) ||
                    🔶visitNode(cbNode, node.name) ||
                    🔶visitNodes(cbNodes, node.typeParameters) ||
                    🔶visitNodes(cbNodes, node.heritageClauses) ||
                    🔶visitNodes(cbNodes, node⚠️.members);
            case 228:
                return 🔶visitNodes(cbNodes, node.decorators) ||
                    🔶visitNodes(cbNodes, node.modifiers) ||
                    🔶visitNode(cbNode, node.name) ||
                    🔶visitNodes(cbNodes, node.typeParameters) ||
                    🔶visitNode(cbNode, node.type);
            case 229:
                return 🔶visitNodes(cbNodes, node.decorators) ||
                    🔶visitNodes(cbNodes, node.modifiers) ||
                    🔶visitNode(cbNode, node.name) ||
                    🔶visitNodes(cbNodes, node.members);
            case 260:
                return 🔶visitNode(cbNode, node.name) ||
                    🔶visitNode(cbNode, node.initializer);
            case 230:
                return 🔶visitNodes(cbNodes, node.decorators) ||
                    🔶visitNodes(cbNodes, node.modifiers) ||
                    🔶visitNode(cbNode, node.name) ||
                    🔶visitNode(cbNode, node.body);
            case 234:
                return 🔶visitNodes(cbNodes, node⚠️.decorators) ||
                    🔶visitNodes(cbNodes, node⚠️.modifiers) ||
                    🔶visitNode(cbNode, node⚠️.name) ||
                    🔶visitNode(cbNode, node⚠️.moduleReference);
            case 235:
                return 🔶visitNodes(cbNodes, node.decorators) ||
                    🔶visitNodes(cbNodes, node.modifiers) ||
                    🔶visitNode(cbNode, node.importClause) ||
                    🔶visitNode(cbNode, node.moduleSpecifier);
            case 236:
                return 🔶visitNode(cbNode, node.name) ||
                    🔶visitNode(cbNode, node.namedBindings);
            case 233:
                return 🔶visitNode(cbNode, node⚠️.name);
            case 237:
                return 🔶visitNode(cbNode, node.name);
            case 238:
            case 242:
                return 🔶visitNodes(cbNodes, node.elements);
            case 241:
                return 🔶visitNodes(cbNodes, node.decorators) ||
                    🔶visitNodes(cbNodes, node.modif
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment