27 

28 
        return $this->explore(
29 
            $type,
30 
            ['with_original_language' => Str::lowercase($code) != 'en' ? $code : null],
31 
            Str::read(
32 
                substr($language, 0, strrpos($language, '-'))
33 
            )
34 
        );
35 
    }
36 

37 
    public function country($type, $country)
38 
    {
39 
        $code = substr($country, strrpos($country, '-') + 1);
40 

41 
        return $this->explore(
42 
            $type,
43 
            ['with_origin_country' => Str::lowercase($code) != 'us' ? $code : null],
44 
            Str::read(
45 
                substr($country, 0, strrpos($country, '-'))
46 
            )
47 
        );
48 
    }
49 

50 
    public function company($type, $slug)
51 
    {
52 
        return $this->explore(

                                

                                    
68 
            (is_string($callback) && function_exists($callback))
69 
            || (is_object($callback) && ($callback instanceof Closure))
70 
        )
71 
            || (is_array($callback) && method_exists($callback[0], $callback[1]));
72 
    }
73 

74 
    public static function load($callback, ...$params)
75 
    {
76 
        if (!self::exists($callback)) {
77 
            throw new UndefinedMethod((is_array($callback) ? (!is_string($callback[0]) ? get_class($callback[0]) : (string) $callback[0]) . '->' . $callback[1] : $callback) . '() does not exists');
78 
        }
79 

80 
        return call_user_func($callback, ...array_values($params));
81 
    }
82 

83 
    public static function create(string $class, ...$args)
84 
    {
85 
        if (!class_exists($class)) {
86 
            throw new UndefinedClass('Class: ' . $class . ' does not exists');
87 
        }
88 

89 
        return new $class(...array_values($args));
90 
    }
91 

92 
    public static function name($callback): string
93 
    {

                                

                                    
106 

107 
            // set new callback method
108 
            $route->setCallback([$route->getCallback()[0], $call_method]);
109 
        }
110 

111 
        // escape grouped/nested named parameter
112 
        $route->setParameters($this->escapeNestedParameters($route->getParameters()));
113 

114 
        // trigger route middleware event
115 
        $this->triggerEvent(IRoute::EVENTS['callback'], $route);
116 

117 
        // load router callback
118 
        return CallbackHandler::load(
119 
            $route->getCallback(),
120 
            ...CallbackHandler::reflect(
121 
                $route->getParameters(),
122 
                $route->getCallback(),
123 
                array_merge($this->getReflectionParameters(), [$route])
124 
            )
125 
        );
126 
    }
127 

128 
    public function callMiddlewares($middlewares): void
129 
    {
130 
        foreach ((array) $middlewares as $middleware) {
131 
            $class = CallbackHandler::create($middleware);

                                

                                    
90 
                // utilize method required paramiters
91 
                $route->setParameters(
92 
                    $this->applyFilters(self::FILTER['parameters'], $this->utilizeRouteParam($matches, $route))
93 
                );
94 

95 
                // set Url to route
96 
                $route->setUrl($url);
97 

98 
                // create route dispatcher
99 
                $dispatcher = new RouteDispatcher($this);
100 

101 
                // dispatch route callback
102 
                return $dispatcher->dispatch($route);
103 
            }
104 
        }
105 

106 
        // call fallback
107 
        if (isset($this->fallback) && CallbackHandler::exists($this->fallback)) {
108 
            CallbackHandler::load($this->fallback);
109 
        }
110 

111 
        // not found any route for this path
112 
        throw new NotFoundException('the route does not matched..');
113 
    }
114 

115 
    /**

                                

                                    
91 
    }
92 

93 
    /**
94 
     * Run The Application
95 
     * @return void
96 
     */
97 
    public static function run(): void
98 
    {
99 
        // load application initial kernels
100 
        self::$app->loadKernels('boot');
101 

102 
        // render router result
103 
        echo self::$app->router->resolve();
104 

105 
        // load application initial kernels
106 
        self::$app->loadKernels('shutdown');
107 
    }
108 

109 
    /**
110 
     * Check Anu Component added to the Application
111 
     * @param string $key 
112 
     * @return bool 
113 
     */
114 
    public static function hasComponent(string $key): bool
115 
    {
116 
        return isset(self::$app->components[$key]);

                                

                                    
14 
    'tmp_dir'   => config('app.tmp_dir'),
15 
    'except'    => ['/admin/*', '/embed/*', '/search/*'],
16 
]);
17 

18 
// serve from cache if production mode
19 
if (!is_dev()) {
20 
    $siteCache->serve();
21 
}
22 

23 
// create a new application instance for this http request
24 
Application::create(__DIR__)
25 
    ->registerKernel(App\Http\Kernels\AppKernel::class)
26 
    ->run();
27 

28 
// stop the application execution process
29 
exit;
30