How to use the @tslab/typescript-for-tslab.SyntaxKind function in @tslab/typescript-for-tslab

const await: ts.Node = ts.tslab.findPrecedingToken(
      d.start + d.length,
      srcFile
    );
    if (await.kind !== ts.SyntaxKind.AwaitKeyword) {
      // This must not happen, though.
      return false;
    }
    let isTop = true;
    let parent = await.parent;
    while (isTop && parent && parent !== srcFile) {
      switch (parent.kind) {
        case ts.SyntaxKind.ArrowFunction:
        case ts.SyntaxKind.FunctionExpression:
        case ts.SyntaxKind.FunctionDeclaration:
        case ts.SyntaxKind.ClassDeclaration:
        case ts.SyntaxKind.ModuleDeclaration:
          // await is not top-level. This is invalid in tslab.
          return false;
      }
      parent = parent.parent;
    }
    return true;
  }

return false;
    }
    const await: ts.Node = ts.tslab.findPrecedingToken(
      d.start + d.length,
      srcFile
    );
    if (await.kind !== ts.SyntaxKind.AwaitKeyword) {
      // This must not happen, though.
      return false;
    }
    let isTop = true;
    let parent = await.parent;
    while (isTop && parent && parent !== srcFile) {
      switch (parent.kind) {
        case ts.SyntaxKind.ArrowFunction:
        case ts.SyntaxKind.FunctionExpression:
        case ts.SyntaxKind.FunctionDeclaration:
        case ts.SyntaxKind.ClassDeclaration:
        case ts.SyntaxKind.ModuleDeclaration:
          // await is not top-level. This is invalid in tslab.
          return false;
      }
      parent = parent.parent;
    }
    return true;
  }

}
    const await: ts.Node = ts.tslab.findPrecedingToken(
      d.start + d.length,
      srcFile
    );
    if (await.kind !== ts.SyntaxKind.AwaitKeyword) {
      // This must not happen, though.
      return false;
    }
    let isTop = true;
    let parent = await.parent;
    while (isTop && parent && parent !== srcFile) {
      switch (parent.kind) {
        case ts.SyntaxKind.ArrowFunction:
        case ts.SyntaxKind.FunctionExpression:
        case ts.SyntaxKind.FunctionDeclaration:
        case ts.SyntaxKind.ClassDeclaration:
        case ts.SyntaxKind.ModuleDeclaration:
          // await is not top-level. This is invalid in tslab.
          return false;
      }
      parent = parent.parent;
    }
    return true;
  }

// https://github.com/microsoft/TypeScript/search?q=await_expression_is_only_allowed_within_an_async_function_1308
      return false;
    }
    const await: ts.Node = ts.tslab.findPrecedingToken(
      d.start + d.length,
      srcFile
    );
    if (await.kind !== ts.SyntaxKind.AwaitKeyword) {
      // This must not happen, though.
      return false;
    }
    let isTop = true;
    let parent = await.parent;
    while (isTop && parent && parent !== srcFile) {
      switch (parent.kind) {
        case ts.SyntaxKind.ArrowFunction:
        case ts.SyntaxKind.FunctionExpression:
        case ts.SyntaxKind.FunctionDeclaration:
        case ts.SyntaxKind.ClassDeclaration:
        case ts.SyntaxKind.ModuleDeclaration:
          // await is not top-level. This is invalid in tslab.
          return false;
      }
      parent = parent.parent;
    }
    return true;
  }

function isTopLevelAwaitDiagnostic(
    srcFile: ts.SourceFile,
    d: ts.Diagnostic
  ): boolean {
    if (d.code !== 1308) {
      // https://github.com/microsoft/TypeScript/search?q=await_expression_is_only_allowed_within_an_async_function_1308
      return false;
    }
    const await: ts.Node = ts.tslab.findPrecedingToken(
      d.start + d.length,
      srcFile
    );
    if (await.kind !== ts.SyntaxKind.AwaitKeyword) {
      // This must not happen, though.
      return false;
    }
    let isTop = true;
    let parent = await.parent;
    while (isTop && parent && parent !== srcFile) {
      switch (parent.kind) {
        case ts.SyntaxKind.ArrowFunction:
        case ts.SyntaxKind.FunctionExpression:
        case ts.SyntaxKind.FunctionDeclaration:
        case ts.SyntaxKind.ClassDeclaration:
        case ts.SyntaxKind.ModuleDeclaration:
          // await is not top-level. This is invalid in tslab.
          return false;
      }
      parent = parent.parent;

d.start + d.length,
      srcFile
    );
    if (await.kind !== ts.SyntaxKind.AwaitKeyword) {
      // This must not happen, though.
      return false;
    }
    let isTop = true;
    let parent = await.parent;
    while (isTop && parent && parent !== srcFile) {
      switch (parent.kind) {
        case ts.SyntaxKind.ArrowFunction:
        case ts.SyntaxKind.FunctionExpression:
        case ts.SyntaxKind.FunctionDeclaration:
        case ts.SyntaxKind.ClassDeclaration:
        case ts.SyntaxKind.ModuleDeclaration:
          // await is not top-level. This is invalid in tslab.
          return false;
      }
      parent = parent.parent;
    }
    return true;
  }

sym.declarations.forEach(decl => {
        let node = decl as ts.Node;
        while (node.parent !== declsSF) {
          node = node.parent;
        }
        if (node.kind === ts.SyntaxKind.VariableStatement) {
          if (keep.value) {
            addName(node, key);
            if (anyVars.has(key)) {
              anyVars.delete(key);
            }
            valueNames.add(key);
          }
          return;
        }
        if (ts.isTypeAliasDeclaration(node)) {
          if (keep.type) {
            addName(node, key);
          }
          return;
        }
        if (ts.isClassDeclaration(node) || ts.isEnumDeclaration(node)) {

return (node: ts.SourceFile) => {
        for (let i = node.statements.length - 1; i >= 0; i--) {
          const stmt = node.statements[i];
          if (ts.isExportDeclaration(stmt)) {
            continue;
          }
          if (!ts.isExpressionStatement(stmt)) {
            break;
          }
          const lastName = createLastExprVar();
          let statements = node.statements.slice(0, i);
          statements.push(
            ts.createVariableStatement(
              [ts.createModifier(ts.SyntaxKind.ExportKeyword)],
              ts.createVariableDeclarationList(
                [
                  ts.createVariableDeclaration(
                    lastName,
                    undefined,
                    stmt.expression
                  )
                ],
                ts.NodeFlags.Const
              )
            )
          );
          setLastExprName(lastName);
          statements.push(...node.statements.slice(i + 1));
          node.statements = ts.createNodeArray(statements);
          break;