public static function unavailable($send = true) {
    return static::status(503, $send);
  }
 
  /**
   * Sends a redirect header
   * 
   * @param boolean $send
   * @return string|null
   */
  public static function redirect($url, $code = 301, $send = true) {
 
    $status   = static::status($code, false); 
    $location = 'Location:' . $url;
 
    if(!$send) {
      return $status . "\r\n" . $location;
    }
 
    header($status);
    header($location);
    exit();
 
  }
 
  /**
   * Sends download headers for anything that is downloadable 
   * 
   * @param array $params Check out the defaults array for available parameters
   */
   public static function download($params = array()) {
 
    $defaults = array(
      'name'     => 'download',
      'size'     => false,
      'mime'     => 'application/force-download',
      'modified' => time()
    );
 
    $options = array_merge($defaults, $params);

 * Helps redirecting to various places in your app
 * Combined with custom handlers of URL::to, this can be really smart and handy
 * 
 * @package   Kirby Toolkit 
 * @author    Bastian Allgeier <bastian@getkirby.com>
 * @link      http://getkirby.com
 * @copyright Bastian Allgeier
 * @license   http://www.opensource.org/licenses/mit-license.php MIT License
 */
class Redirect {
 
  /**
   * Redirects the user to a new URL
   *
   * @param   string    $url The URL to redirect to
   * @param   boolean   $code The HTTP status code, which should be sent (301, 302 or 303)
   * @param   boolean   $send If true, headers will be sent and redirection will take effect
   */
  public static function send($url = false, $code = false, $send = true) {
    return header::redirect($url, $code, $send);
  }
 
  /**
   * Redirects to a specific URL. You can pass either a normal URI
   * a controller path or simply nothing (which redirects home)
   * You can also pass a second param with the HTTP status code
   */
  public static function to() {
    $args = func_get_args();
 
    // if the last element is a number, use it as HTTP status code
    $code = false;
    if(is_int(end($args))) {
      $code = array_pop($args);
    }
 
    return static::send(call_user_func_array(array('url', 'to'), $args), $code);
  }
 
  /**

 
      }
 
      return $page;
 
    };
 
    // tinyurl handling
    $routes['tinyurl'] = $this->component('tinyurl')->route();
 
    // home redirect
    $routes['homeRedirect'] = array(
      'pattern' => $this->options['home'] . '(\..*)?',
      'action'  => function($extension = null) {
        // ignore invalid extensions
        if($extension === '.') $extension = '';
 
        redirect::send(url::build([
          'fragments' => ($extension)? [$extension] : null
        ]), 307);
      }
    );
 
    // plugin assets
    $routes['pluginAssets'] = array(
      'pattern' => 'assets/plugins/(:any)/(:all)',
      'method'  => 'GET',
      'action'  => function($plugin, $path) use($kirby) {
        $root = $kirby->roots()->plugins() . DS . $plugin . DS . 'assets' . DS . $path;
        $file = new Media($root);
 
        if($file->exists()) {
          return new Response(f::read($root), f::extension($root));
        } else {          
          return new Response('The file could not be found', f::extension($path), 404);
        }
      }
    );
 
    // all other urls

 
/**
 * Facepalm typo alias
 * @see csrf()
 */
function csfr() {
  return call('csrf', func_get_args());
}
 
/**
 * Shortcut for call_user_func_array with a better handling of arguments
 *
 * @param mixed $function
 * @param mixed $arguments
 * @return mixed
 */
function call($function, $arguments = array()) {
  if(!is_callable($function)) return false;
  if(!is_array($arguments)) $arguments = array($arguments);
  return call_user_func_array($function, $arguments);
}
 
/**
 * Parses yaml structured text
 *
 * @param $string
 * @return array
 */
function yaml($string) {
  return yaml::decode($string);
}
 
/**
 * Simple email sender helper
 *
 * @param array $params
 * @return Email
 */
function email($params = array()) {
  return new Email($params);

 
    // load all plugins
    $this->plugins();
 
    // start the router
    $this->router = new Router($this->routes());
    $this->route  = $this->router->run($this->path());
 
    // check for a valid route
    if(is_null($this->route)) {
      header::status('500');
      header::type('json');
      die(json_encode(array(
        'status'  => 'error',
        'message' => 'Invalid route or request method'
      )));
    }
 
    // call the router action with all arguments from the pattern
    $response = call($this->route->action(), $this->route->arguments());
 
    // load all language variables
    // this can only be loaded once the router action has been called
    // otherwise the current language is not yet available
    $this->localize();
 
    // build the response
    $this->response = $this->component('response')->make($response);
 
    // store the current language in the session
    if(
        $this->option('language.detect') &&
        $this->site()->multilang() && 
        $this->site()->language()
      ) {      
      s::set('kirby_language', $this->site()->language()->code());
    }
 
    return $this->response;
 

<?php
 
define('DS', DIRECTORY_SEPARATOR);
 
// load kirby
require(__DIR__ . DS . 'kirby' . DS . 'bootstrap.php');
 
// check for a custom site.php
if(file_exists(__DIR__ . DS . 'site.php')) {
  require(__DIR__ . DS . 'site.php');
} else {
  $kirby = kirby();
}
 
// render
echo $kirby->launch();