Javascript can'；t使用puppeter导出异步函数

我正在尝试导出一个异步函数，该函数返回要在另一个文件中使用的对象数据。。。我有很多麻烦。我真的很感激任何帮助

代码：

const puppeter=require（'puppeter'）；
（异步（）=>{
let browser=wait puppeter.launch（{args:['--no sandbox']，headless:true}）；
let page=等待browser.newPage（）；
//JCC网址：
让ph_jcc_pool_url=https://jcc.org/park-heights-indoor-pool-registration';
//转到park heights游泳池注册url:
wait page.goto（ph_jcc_pool_url，{waitUntil:'networkidle0'}）；
//评估公园高地游泳池注册：
让刮取的池=等待页面。评估（（）=>{
让插槽_数组=[]；
$（“.GXPEntry”）。每个（函数（索引，元素）{
插槽_阵列[索引]={
已取消：空，
todaySlotTimePassed:null，
displayDayHeading:null，
可注册：null，
时间：element.querySelector（“.GXPTime”）.textContent，
dayOfWeek:$（元素）.parent（）.attr（'id'）.replace（'GXP'，“”），
日期：element.querySelector（“a.descGXP”）.getAttribute（“数据日期”），
slotType:element.querySelector（'.GXPTitle'）.textContent，
性别：空，
可用性：空，
签名：空，
appleCalendarLink:null，
位置：element.querySelector（“.GXPLocation”）.textContent，
studio:element.querySelector（“.GXPStudio”）.textContent.slice（0，-1），
};
//检查插槽是否已取消
//-如果取消，则设置为取消
//-如果没有，则获取仅显示未取消项目的数据
if（插槽_数组[index].slotType.includes（“取消”）||插槽_数组[index].slotType.includes（“取消”））{
插槽\u数组[索引]。已取消=true；
}否则{
插槽\u数组[索引]。已取消=false；
slots_数组[index].signUpLink=element.querySelector（'a.signUpGXP'）.getAttribute（“href”）；
插槽数组[index].availability=element.querySelector（'div.GXPDescription span'）.textContent；
}
//选中性别并将类型字符串设置为.gender
if（插槽数组[index].slotType.includes（“女性”））{
插槽数组[index].gender=“Female”；
}否则{
插槽数组[index].gender=“Male”；
}
})；//关闭.each（“.GXPEntry”）迭代器函数
返回槽单元阵列；
})；//关闭等待页面。评估jcc公园高度
//park heights jcc泳池注册数据：
让ph_jcc_池={
main:scraped_ph_jcc_pool，//要显示的主要条目
取出：[]，//以额外的手风琴风格显示
天数：[//以导航方式显示
}
//从time.js.test time为今天的特定插槽添加slotTimePassed数据
//--返回--
//错误：时间尚未过去，应显示内容
//正确：时间已经过去，应该隐藏起来
让时间=要求（“/时间”）；
ph_jcc_pool.main.forEach（函数（对象，索引）{
//如果每个对象的时间已过，请标记true或false
object.todaySlotTimePassed=
time.calculateIfSlotTimePassed（ph_jcc_pool.main[index].date，ph_jcc_pool.main[index].time）；
//将（从今天起）过去的对象推送到新阵列
if（time.calculateIfSlotTimePassed（ph_jcc_pool.main[index].date，ph_jcc_pool.main[index].time）
==真）{
ph_jcc_池。取出。推（对象）；
}
})；//forEach（）的关闭时间
//如果从今天起未取出任何物品，则返回false
if（ph_jcc_pool.take_out.length==0）{
ph_jcc_pool.take_out=false；
}
//从ph_jcc_pool_数据数组中删除todaySlotTimePassed项
ph_jcc_pool.main=ph_jcc_pool.main.filter（函数（对象）{
return object.todaySlotTimePassed！==true；
})
//测试何时放置日标题。如果为真，则为是；如果为假，则为否。
对于（设i=0；i这应该有效：

//在get-data.js中
const puppeter=require（'puppeter'）；
异步函数getData（）{
const browser=wait puppeter.launch（）；
// ...
返回数据；
}
module.exports={
获取数据，
};

//在main.js中
const{getData}=require（'./get data.js'）；
（异步函数main（）{
试一试{
const data=wait getData（）；
控制台日志（数据）；
}捕捉（错误）{
控制台错误（err）；
}
})();
试图将此数据传输到快速路径中的另一个文件又一次发生了如此多的问题..这是两次保存：）。您知道如何将此数据传输到快速路径中吗？对不起，我不知道(
    const puppeteer = require('puppeteer');

(async () => {
    let browser = await puppeteer.launch({ args: ['--no-sandbox'] , headless: true});
    let page = await browser.newPage();

    // JCC URL's:
    let ph_jcc_pool_url = 'https://jcc.org/park-heights-indoor-pool-registration';

    // go to park heights pool registration url:
    await page.goto(ph_jcc_pool_url, {waitUntil: 'networkidle0'});

    // evaluate park heights pool registration:
    let scraped_ph_jcc_pool = await page.evaluate(() => {
        let slots_array = [];

        $(".GXPEntry").each(function (index, element) {
           slots_array[index] = {
                cancelled: null,
                todaySlotTimePassed: null,
                displayDayHeading: null,
                signUpAble: null,
                time: element.querySelector(".GXPTime").textContent,
                dayOfWeek: $(element).parent().attr('id').replace("GXP", ""),
                date: element.querySelector("a.descGXP").getAttribute("data-date"),
                slotType: element.querySelector('.GXPTitle').textContent,
                gender: null,
                availability: null,
                signUpLink: null,
                appleCalendarLink: null,
                location: element.querySelector(".GXPLocation").textContent,
                studio: element.querySelector(".GXPStudio").textContent.slice(0, -1),
            };

            // Check if slot is cancelled or not
                // - if cancelled, set as cancelled
                // - if not, get data that only shows if item not cancelled
            if (slots_array[index].slotType.includes("CANCELED") || slots_array[index].slotType.includes("CANCELLED")) {
                slots_array[index].cancelled = true;
            } else {
                slots_array[index].cancelled = false;
                slots_array[index].signUpLink = element.querySelector('a.signUpGXP').getAttribute("href");
                slots_array[index].availability = element.querySelector('div.GXPDescription span').textContent;
            }

            // Check gender and set type string to .gender
            if (slots_array[index].slotType.includes("Women")) {
                slots_array[index].gender = "Female";
            } else {
                slots_array[index].gender = "Male";
            }

        }); // close .each(".GXPEntry") iterator function

        return slots_array;

    }); // close await page.evaluate jcc park heights

    // park heights jcc pool registration data:
    let ph_jcc_pool = {
        main: scraped_ph_jcc_pool, // main entries to be displayed
        taken_out: [], // to display in extra accordion style
        days: [] // to display in nav
    }

    // add slotTimePassed data from time.js. test time for specific slots of TODAY
    // --Returns--:
    // FALSE: time has not passed and content should be displayed
    // TRUE: time has passed and should be hidden
    let time = require("./time");
    ph_jcc_pool.main.forEach(function (object, index) {
        // mark true or false if time has passed for each object
        object.todaySlotTimePassed =
            time.calculateIfSlotTimePassed(ph_jcc_pool.main[index].date, ph_jcc_pool.main[index].time);

        // push objects that are (from today) in the past to new array
        if (time.calculateIfSlotTimePassed(ph_jcc_pool.main[index].date, ph_jcc_pool.main[index].time)
            === true) {
            ph_jcc_pool.taken_out.push(object);
        }
    }); // close time forEach()

    // return false if no items have been taken out from today
    if (ph_jcc_pool.taken_out.length === 0) {
        ph_jcc_pool.taken_out = false;
    }

    // remove todaySlotTimePassed entries from ph_jcc_pool_data array
    ph_jcc_pool.main = ph_jcc_pool.main.filter(function(object) {
        return object.todaySlotTimePassed !== true;
    })

    // test when to put day heading. if true, then yes, if false, then no.
    for (let i = 0; i<ph_jcc_pool.main.length; i++) {
        if (i === 0) {
            ph_jcc_pool.main[0].displayDayHeading = true;
            ph_jcc_pool.days.push(ph_jcc_pool.main[0].dayOfWeek);
        } else {
            if (ph_jcc_pool.main[i - 1].dayOfWeek !== ph_jcc_pool.main[i].dayOfWeek) {
                ph_jcc_pool.main[i].displayDayHeading = true;
                ph_jcc_pool.days.push(ph_jcc_pool.main[i].dayOfWeek);
            } else {
                ph_jcc_pool.main[i].displayDayHeading = false;
            }
        }
    }

    await browser.close();

    return ph_jcc_pool;

})(); // close async function