use() {
        // If we have a context pattern, then this is a contextual Chainable and should not allow middlewares or routers to be bound to it
        if (this.#context_pattern)
            throw new Error(
                'HyperExpress.Router.use() -> Cannot bind middlewares or routers to a contextual router created using Router.route() method.'
            );

        // Parse a pattern for this use call with a fallback to the local-global scope aka. '/' pattern
        const pattern = arguments[0] && typeof arguments[0] == 'string' ? arguments[0] : '/';

        // Validate that the pattern value does not contain any wildcard or path parameter prefixes which are not allowed
        if (pattern.indexOf('*') > -1 || pattern.indexOf(':') > -1)
            throw new Error(
                'HyperExpress: Server/Router.use() -> Wildcard "*" & ":parameter" prefixed paths are not allowed when binding middlewares or routers using this method.'
            );

        // Register each candidate individually depending on the type of candidate value
        for (let i = 0; i < arguments.length; i++) {
            const candidate = arguments[i];
            if (typeof candidate == 'function') {
                // Scenario: Single function
                this._register_middleware(pattern, candidate);
            } else if (Array.isArray(candidate)) {
                // Scenario: Array of functions
                candidate.forEach((middleware) => this._register_middleware(pattern, middleware));
            } else if (typeof candidate == 'object' && candidate.constructor.name === 'Router') {
                // Scenario: Router instance
                this._register_router(pattern, candidate);
            } else if (candidate && typeof candidate == 'object' && typeof candidate.middleware == 'function') {
                // Scenario: Inferred middleware for third-party middlewares which support the Middleware.middleware property
                this._register_middleware(pattern, candidate.middleware);
            }
        }

        // Return this to make the Router chainable
        return this;
    }
Registers middlewares and router instances on the specified pattern if specified.
If no pattern is specified, the middleware/router instance will be mounted on the '/' root path by default of this instance.

@param {...(String|MiddlewareHandler|Router)} args (request, response, next) => {} OR (request, response) => new Promise((resolve, reject) => {})
@returns {this} Chainable instance