Boot the service provider and bind the {area} wildcard to the router.
349036
public function boot()
    {
        $router = $this->app->make(Router::class);

        $router->bind('area', function($value) {
            return $this->app->make(AreaManagerContract::class)->getById($value);
        });

        $router->pushMiddlewareToGroup('web', AreaMiddleware::class);
    }
885895
public function boot()
    {
        parent::boot();

        $config = $this->app['config'];

        // Add the setup wizard routes if asked to
        $loadDefaultRoutes = $config->get('setup_wizard.routing.load_default');
        if ($loadDefaultRoutes && !$this->app->routesAreCached()) {
            require($this->packageDir . '/src/routes.php');
        }

        // Facade
        $this->app->singleton('SetupWizard', function ($app) {
            $wizard = new DefaultSetupWizard($app);

            return $wizard;
        }
        );

        $this->app->alias('SetupWizard', DefaultSetupWizard::class);

        // We have some views and translations for the wizard
        $this->loadViewsFrom($this->packageDir . '/resources/views', self::$RES_NAMESPACE);
        $this->loadTranslationsFrom($this->packageDir . '/resources/lang', self::$RES_NAMESPACE);

        // We publish some files to override if required
        $this->publishes([
            $this->packageDir . '/config/' . self::$CONFIG_FILE => config_path(self::$CONFIG_FILE),
        ], 'config');

        $this->publishes([
            $this->packageDir . '/resources/views' => resource_path('views/vendor/' . self::$RES_NAMESPACE),
        ], 'views');

        $this->publishes([
            $this->packageDir . '/resources/lang' => resource_path('lang/vendor/' . self::$RES_NAMESPACE),
        ], 'translations');

        $this->publishes([
            $this->packageDir . '/resources/assets' => public_path('vendor/' . self::$RES_NAMESPACE),
        ], 'assets');
    }
1273922
public function boot()
    {
        // Publish the cors.php to laravel config dir.
        $this->publishes([__DIR__.'/../../../config/laravel.php' => config_path('cors.php')]);

        $kernel = $this->app->make(Kernel::class);
        // When the Cors middleware is not attached globally.
        if (!$kernel->hasMiddleware(CorsMiddleware::class)) {
            $kernel->prependMiddleware(CorsMiddleware::class);
        }
    }
439384
public function bootstrap()
    {
        $this->router = $this->app['router'];
        $this->middlewareGroups = array_merge([], $this->middlewareGroups, config('routing.middlewareGroups', []));
        $this->routeMiddleware = array_merge([], $this->routeMiddleware, config('routing.routeMiddleware', []));

        foreach ($this->middlewareGroups as $key => $middleware) {
            $this->router->middlewareGroup($key, $middleware);
        }

        foreach ($this->routeMiddleware as $key => $middleware) {
            $this->router->middleware($key, $middleware);
        }
    }
888391
public function boot()
  {
    if (!is_dir(Remember::$tokensDir)) {
      mkdir(Remember::$tokensDir, 0777, true);
    }

    $this->hasTokens();
    $this->configure();
    $this->start();
  }
792283
public void start() 
		{
		        try 
		        {
		            this.regularBootstrap.bind(new InetSocketAddress(regularConfiguration.getHost(), regularConfiguration.getPort()));
		            if(logger.isInfoEnabled()) {
		            logger.info(regularConfiguration.getName() + " started at " + regularConfiguration.getHost() + " : " + regularConfiguration.getPort());
		            }
		            if(this.securedConfiguration!=null)
		            {
		            	this.securedBootstrap.bind(new InetSocketAddress(securedConfiguration.getHost(), securedConfiguration.getPort()));	
		            	if(logger.isInfoEnabled()) {
		            	logger.info(securedConfiguration.getName() + " uses port : " + securedConfiguration.getPort() + " for TLS clients.");
		            	}
		            }
		        } 
		        catch (ChannelException e) 
		        {
		        	logger.error("Smpp Channel Exception:", e);
		        }
		}
246565
function() {
			var baseUrl = context.getGlobal('location').pathname;

			routerService = context.getService('router');
			routerService.init([
				baseUrl,
				baseUrl + 'active',
				baseUrl + 'completed'
			]);
		}
854245
private function bootProviders()
    {
        foreach ($this->providers as $provider) {
            if ($provider instanceof Closure) {
                $provider($this);
            } else {
                (new $provider($this))->boot();
            }
        }
    }
545428
def bind(self, server, net=None, address=None):
        """"""
        if _debug: NetworkServiceAccessPoint._debug("bind %r net=%r address=%r", server, net, address)

        # make sure this hasn't already been called with this network
        if net in self.adapters:
            raise RuntimeError("already bound")

        # create an adapter object, add it to our map
        adapter = NetworkAdapter(self, net)
        self.adapters[net] = adapter
        if _debug: NetworkServiceAccessPoint._debug("    - adapters[%r]: %r", net, adapter)

        # if the address was given, make it the "local" one
        if address and not self.local_address:
            self.local_adapter = adapter
            self.local_address = address

        # bind to the server
        bind(adapter, server)
276136
public function boot()
    {
        parent::boot();

        if (Request::is('*/page/page/*')) {
            Route::bind('page', function ($id) {
                $page = $this->app->make(\Litecms\Page\Interfaces\PageRepositoryInterface::class);
                return $page->findOrNew($id);
            });
        }

    }
761907
public function boot()
	{
		if ($this->booted) return;

		array_walk($this->serviceProviders, function($p) { $p->boot(); });

		$this->bootApplication();
	}
527307
public static function boot()
    {
        parent::boot();

        self::creating(function ($user) {
            if (!$user->api_key) {
                $user->api_key = self::generateApiKey();
            }
        });
    }
1236643
public function boot()
    {
        $this->registerPolicies();

        $this->loadViewsFrom(__DIR__.'/Views', 'laralum_routes');
        $this->loadTranslationsFrom(__DIR__.'/Translations', 'laralum_routes');

        if (!$this->app->routesAreCached()) {
            require __DIR__.'/Routes/web.php';
        }

        // Make sure the permissions are OK
        PermissionsChecker::check($this->permissions);
    }
231703
public function boot()
    {
        $base = [
            'base_uri' => 'https://api.ipgeolocation.io/',
        ];

        if ($this->config('key')) {
            $base['base_uri'] = "{$base['base_uri']}ipgeo?apiKey=" . $this->config('key');
        }

        $this->client = new HttpClient($base);
    }
1098785
public function boot()
    {
        $this->publishes(
            [
                $this->getConfigPath() => config_path('vanilla-integration.php'),
            ],
            'config'
        );
        $this->loadRoutesFrom(__DIR__ . '/../../../routes/routes.php');
        $this->registerHelpers();
    }
110525
public function boot()
    {
        $required_providers = [
            ExtendedValidatorServiceProvider::class,
            StaticReferencesServiceProvider::class,
        ];

        foreach ($required_providers as $required_provider) {
            if (! $this->serviceProviderIsRegistered($required_provider)) {
                $this->app->register($required_provider);
            }
        }
    }
442518
public function boot()
    {
        $router = $this->app['router'];

        $router->middlewareGroup('soda.web', [Drafting::class]);
        $router->middlewareGroup('soda.api', [Drafting::class]);

        $router->pushMiddlewareToGroup('web', TransferSession::class);
        $router->pushMiddlewareToGroup('web', DraftAlert::class);
        $router->pushMiddlewareToGroup('web', ToggleLocale::class);
        if (config('soda.cms.https')) {
            $router->pushMiddlewareToGroup('soda.web', ForceHttps::class);
        }

        $router->aliasMiddleware('soda.auth', Authenticate::class);
        $router->aliasMiddleware('soda.guest', RedirectIfAuthenticated::class);

        $router->aliasMiddleware('soda.role', HasRole::class);
        $router->aliasMiddleware('soda.permission', HasPermission::class);
        $router->aliasMiddleware('soda.ability', HasAbility::class);

        $middlewareGroups = $router->getMiddlewareGroups();

        if (isset($middlewareGroups['web'])) {
            if (($key = array_search('Illuminate\Session\Middleware\StartSession', $middlewareGroups['web'])) !== false) {
                $middlewareGroups['web'][$key] = SluggableSession::class;
                array_unshift($router->middlewarePriority, SluggableSession::class);
            }

            $router->middlewareGroup('soda.sluggable-web', $middlewareGroups['web']);
        }

        parent::boot();
    }