worker.cjs

const AccessControl = {
    enabled: false,
    // `Block` or `Allow`.
    method: "Block",
    // More key can be found in http header.
    follow: "Referer", 
    // note: it will not correct your spell mistakes automaticlly
    FuzzyMatching: true,
    // ...i dont know how to explain this
    List: []
}

const AvailableProvider = [
    "github"
    // ,
    // "gravatar"
];

addEventListener("fetch", event => {
    event.respondWith(main(event.request));
})

async function main(request) {
    const CurrentURL = new URL(request.url),
          RequestHeaders = new Headers(request.headers);

    if (AccessControl.enabled === true) {
        const FollowValue = RequestHeaders.get(AccessControl.follow);
        let isBlockRequest;
        if (AccessControl.FuzzyMatching === true) {
            for (let i=0; i<AccessControl.List.length; i++) {
                let status = AccessControl.List[i].includes(FollowValue);
                if (status) {
                    isBlockRequest = true;
                }
            }
            isBlockRequest = false;
        } else {
            isBlockRequest = AccessControl.List.includes(FollowValue);
        }
        if (isBlockRequest) {
            return new Response("403 Forbidden, This request has been blocked due the owner's config.", {
                status: 400,
                headers: DefaultHeader.Response
            });
        }
    }

    if (CurrentURL.pathname.startsWith("/icon/")) {
        const ServiceProvider = CurrentURL.pathname.split("/icon/")[1],
              ID = GetQueryString("id", CurrentURL.search);

        if (!ServiceProvider) {
            return new Response("400 Bad Request, Please specify the service provider.", {
                status: 400,
                headers: DefaultHeader.Response
            });
        }

        if (!ID) {
            return new Response("400 Bad Request, Please specify a user.", {
                status: 400,
                headers: DefaultHeader.Response
            });
        }
        if (!AvailableProvider.includes(ServiceProvider)) {
            return new Response("404 Not Found, Unsupported service provider", {
                status: 400,
                headers: DefaultHeader.Response
            });
        }

        return await HandleIconProxy(ServiceProvider, ID, CurrentURL.host);
    }

    if (CurrentURL.pathname.startsWith("/favicon.ico")) {
        return new Response("204 No Content", {
            status: 204,
            headers: DefaultHeader.Response
        });
    }

    return new Response("200 OK, Here is a kobe-koto/Icon-Proxy service, Ping Pong!", {
        status: 200,
        headers: DefaultHeader.Response
    });
}

async function HandleIconProxy (ServiceProvider, ID, OriginHost) {

    let TargetURL;
    if (ServiceProvider === "github") {
        let Data = await fetch(`https://api.github.com/users/${ID}`, {
            headers: DefaultHeader.Request
        });
        if (Data.status === 304 || Data.status === 200) {
            Data = await Data.json();
            TargetURL = Data.avatar_url;
        } else if (Data.status === 404) {
            return new Response("404 Not Found, The icon for the ID is not found.", {
                status: 404,
                headers: DefaultHeader.Response
            })
        }
    } else if (ServiceProvider === "gravatar") {}

    const OriginalResponse = await fetch(TargetURL, {
        headers: DefaultHeader.Request
    })
    
    return new Response(OriginalResponse.body, {
        status: OriginalResponse.status,
        headers: {
            "Content-Type": new Headers(OriginalResponse.headers).get("Content-Type"),
            "Access-Control-Allow-Origin": OriginHost,
            "Access-Control-Allow-Credentials": "true",
            "Cache-Control": "public, max-age=2592000",
            "X-Robots-Tag": "noindex"
        }
    });
}


function GetQueryString (name, query) {
    const reg = new RegExp(`(^|&)${name}=([^&]*)(&|$)`, "i");
    let r = query.slice(1).match(reg);

    return !!r ? r[2] : null;
}

const DefaultHeader = {
    Response: {
        "Content-Type": "text/plain",
        "Access-Control-Allow-Origin": "*",
        "X-Robots-Tag": "noindex"
    },
    Request: {
        "User-Agent": "curl/8.2.1"
    }
}