async listen(first, second, third) {
        let port;
        let path;

        // Determine if first argument is a number or string castable to a port number
        if (typeof first == 'number' || (+first > 0 && +first < 65536)) {
            // Parse the port number
            port = typeof first == 'string' ? +first : first;
        } else if (typeof first == 'string') {
            // Parse the path to a UNIX domain socket
            path = first;
        }

        let host = '0.0.0.0'; // Host by default is 0.0.0.0
        let callback; // Callback may be optionally provided as second or third argument
        if (second) {
            // If second argument is a function then it is the callback or else it is the host
            if (typeof second === 'function') {
                callback = second;
            } else {
                // Ensure the second argument is a string
                if (typeof second == 'string') {
                    host = second;
                } else {
                    throw new Error(
                        `HyperExpress.Server.listen(): The second argument must either be a callback function or a string as a hostname.`
                    );
                }

                // If we have a third argument and it is a function then it is the callback
                if (third && typeof third === 'function') callback = third;
            }
        }

        // If the server is using SSL then verify that the provided SSL certificate and key files exist and are readable
        if (this.#options.is_ssl) {
            const { cert_file_name, key_file_name } = this.#options;
            try {
                // Verify that both the key and cert files exist and are readable
                await Promise.all([fs.access(key_file_name), fs.access(cert_file_name)]);
            } catch (error) {
                throw new Error(
                    `HyperExpress.Server.listen(): The provided SSL certificate file at "${cert_file_name}" or private key file at "${key_file_name}" does not exist or is not readable.\n${error}`
                );
            }
        }

        // Bind the server to the specified port or unix domain socket with uWS.listen() or uWS.listen_unix()
        const reference = this;
        return await new Promise((resolve, reject) => {
            // Define a callback to handle the listen socket from a listen event
            const on_listen_socket = (listen_socket) => {
                // Compile the Server instance to cache the routes and middlewares
                reference._compile();

                // Determine if we received a listen socket
                if (listen_socket) {
                    // Store the listen socket for future closure
                    reference.#listen_socket = listen_socket;

                    // Bind the auto close handler if enabled from constructor options
                    if (reference.#options.auto_close) reference._bind_auto_close();

                    // Serve the list socket over callback if provided
                    if (callback) callback(listen_socket);

                    // Resolve the listen socket
                    resolve(listen_socket);
                } else {
                    reject(
                        'HyperExpress.Server.listen(): No Socket Received From uWebsockets.js likely due to an invalid host or busy port.'
                    );
                }
            };

            // Determine whether to bind on a port or unix domain socket with priority to port
            if (port !== undefined) {
                reference.#uws_instance.listen(host, port, on_listen_socket);
            } else {
                reference.#uws_instance.listen_unix(on_listen_socket, path);
            }
        });
    }
Starts HyperExpress webserver on specified port and host, or unix domain socket.

@param {Number|String} first Required. Port or unix domain socket path to listen on. Example: 80 or "/run/listener.sock"
@param {(String|function(import('uWebSockets.js').listen_socket):void)=} second Optional. Host or callback to be called when the server is listening. Default: "0.0.0.0"
@param {(function(import('uWebSockets.js').us_listen_socket):void)=} third Optional. Callback to be called when the server is listening.
@returns {Promise<import('uWebSockets.js').us_listen_socket>} Promise which resolves to the listen socket when the server is listening.