How to use the babel-generator function in babel-generator

export function cg(ast, opts = {}) {
  var res
  if (ast == null) {
    // console.error("")
    return ""
  }
  try {
    if (Array.isArray(ast)) {
      ast = ast.length > 0 && T.isExpression(ast[0]) 
        ? T.sequenceExpression(ast)
        : T.blockStatement(ast)
    }
    res = generate(ast,opts,"").code
  } catch (e) {
    if (ast.type != null)
      console.error(e.stack)
  }
  if (res != null)
    return res
  try {
    return "!!" + opts.compact ? JSON.stringify(ast) : JSON.stringify(ast,null,2)
  } catch(e) {
    return ""
  }
}

const getObj = n => json5.parse(generator(n).code)

node.expressions.forEach((e, i) => {
      const r = `___styledjsxexpression${i}___`
      source += node.quasis[i].value.cooked + r
      replacements.push({
        replacement: r,
        initial: `$\{${generate(e).code}}`
      })
    })
    source += node.quasis[node.quasis.length - 1].value.cooked

`, {sourceType: 'module'});
      }
    case 'INTERFACE':
      return parse(`
          ${generate(declaration).code}
          ${generate(moduleExport).code}
      `, {sourceType: 'module'});
    case 'INPUT_OBJECT':
      return parse(`
          ${generate(declaration).code}
          ${generate(moduleExport).code}
      `, {sourceType: 'module'});
    default:
      return parse(`
          ${generate(declaration).code}
          ${generate(moduleExport).code}
      `, {sourceType: 'module'});
  }
}

${generate(queryTypeAssignment).code}
    ${generate(mutationTypeAssignment).code}
    ${generate(subscriptionTypeAssignment).code}

    function recursivelyFreezeObject(structure) {
      Object.getOwnPropertyNames(structure).forEach((key) => {
        const value = structure[key];
        if (value && typeof value === 'object') {
          recursivelyFreezeObject(value);
        }
      });
      Object.freeze(structure);
      return structure;
    }

    ${generate(moduleExport).code}
  `, {sourceType: 'module'});
}

function output(ctx) {
  const result = generate(ctx.jsxBodyTree);
  const code = transformBody(ctx.type, result.code);

  if (ctx.type === typeClass) {
    return outputFunctional(ctx, code);
  }

  return outputClass(ctx, code);
}

])
          ))
        }
      })
    }
  }
  resetTSClassProperty(mainClass.node.body.body)
  if (options.isApp) {
    renderMethod.replaceWith(
      t.classMethod('method', t.identifier('_createData'), [], t.blockStatement([]))
    )
    return { ast } as TransformResult
  }
  //@fix add arg => componentSourceMap
  result = new Transformer(mainClass, options.sourcePath, componentProperies, componentSourceMap).result
  result.code = generate(ast).code
  result.ast = ast
  const lessThanSignReg = new RegExp(lessThanSignPlacehold, 'g')
  result.compressedTemplate = result.template
  result.template = prettyPrint(result.template, {
    max_char: 0,
    unformatted: process.env.NODE_ENV === 'test' ? [] : ['text']
  })
  result.template = result.template.replace(lessThanSignReg, '<')
  result.imageSrcs = Array.from(imageSource)
  return result
}

return t.objectProperty(keyNode, valueNode);
          })
        )
      )
    );

    const comment =
      "\n" +
      stripIndent`
        This file was generated by the run-on-server babel plugin. It should not
        be edited by hand.
      ` +
      "\n";

    const output = generate(t.program([outputContent]), {
      auxiliaryCommentBefore: comment,
    });

    return output.code;
  }

if (moduleExports.size > 0) {
      bundleSource.body.push(babel.exportNamedDeclaration(
          undefined, [babel.exportSpecifier(
                         babel.identifier(starExportName),
                         babel.identifier(starExportName))]));
      bundleSource.body.push(babel.exportNamedDeclaration(
          undefined,
          [...moduleExports].map(
              (e) => babel.exportSpecifier(
                  babel.identifier(e),
                  babel.identifier(getOrSetBundleModuleExportName(
                      assignedBundle, sourceUrl, e)))),
          babel.stringLiteral(rebasedSourceUrl)));
    }
  }
  const {code} = generate(bundleSource);
  return code;
}

function getSourceForVariableDeclarationFromAst(
  types: BabelTypes,
  kind: string,
  node: Object
) {
  const program = types.program([types.variableDeclaration(kind, [node])]);
  return generate(program).code;
}