Register the blade minifier class.

@return void
769657
protected function registerBladeMinifier()
    {
        $this->app->singleton('htmlmin.blade', function (Container $app) {
            $force = $app->config->get('htmlmin.force', false);

            return new BladeMinifier($force);
        });

        $this->app->alias('htmlmin.blade', BladeMinifier::class);
    }
1052290
public function register()
    {
        $this->mergeConfigFrom( __DIR__ . '/../config/laravel-glide.php', 'laravel-glide' );

        $configuration = config( 'laravel-glide' );

        $this->app->bind( 'glide-image', function () use ( $configuration )
        {
            return new GlideImageService( $configuration );
        } );
    }
653060
public function registerEngineResolver() {
        $this->app->singleton('view.engine.resolver', function () {
            $resolver = new EngineResolver;

            // Next we will register the various engines with the resolver so that the
            // environment can resolve the engines it needs for various views based
            // on the extension of view files. We call a method for each engines.
            foreach(['php', 'blade', 'bladeString'] as $engine) {
                $this->{'register' . ucfirst($engine) . 'Engine'}($resolver);
            }

            return $resolver;
        });
    }
1042445
public function registerEngineResolver()
    {
        $self = $this;

        $this->container->singleton('view.engine.resolver', function($app) use ($self) {
            $resolver = new EngineResolver;
            $self->registerPhpEngine($resolver);
            $self->registerBladeEngine($resolver);
            return $resolver;
        });
    }
630814
public function registerBladeStringEngine($resolver) {
        $app = $this->app;

        // The Compiler engine requires an instance of the CompilerInterface, which in
        // this case will be the Blade compiler, so we'll first create the compiler
        // instance to pass into the engine so it can compile the views properly.

        $app->singleton('blade.string.compiler', function ($app) {
            $cache = $app['config']['view.compiled'];

            return new BladeStringCompiler($app['files'], $app['blade.compiler'], $cache);
        });

        $resolver->register('blade.string', function () use ($app) {
            return new CompilerEngine($app['blade.string.compiler'], $app['files']);
        });
    }
333280
public function register()
    {
        $app = $this->app;
        $resolver = $app['view.engine.resolver'];
        
        $app->singleton('inky.compiler', function ($app) {
            $cache = $app['config']['view.compiled'];
            
            return new InkyCompiler($app['blade.compiler'], $app['files'], $cache);
        });

        $resolver->register('inky', function () use ($app) {
            return new InkyCompilerEngine($app['inky.compiler'], $app['files']);
        });
    }
875826
public static function register()
    {
        if (!in_array(self::FILTERNAME, stream_get_filters(), true)) {
            stream_filter_register(self::FILTERNAME, self::class);
        }
    }
84938
public static function register()
    {
        $filtername = self::FILTERNAME.'.*';
        if (!in_array($filtername, stream_get_filters(), true)) {
            stream_filter_register($filtername, self::class);
        }
    }
58627
public function registerMacros()
    {
        $pageKeyword = $this->pageKeyword;
        $router = $this->router;

        $router->macro('paginate', function ($uri, $action) use ($pageKeyword, $router) {
            $route = null;

            $router->group(
                ['middleware' => 'Spatie\PaginateRoute\SetPageMiddleware'],
                function () use ($pageKeyword, $router, $uri, $action, &$route) {
                    $route = $router->get($uri.'/{pageQuery?}', $action)->where('pageQuery', $pageKeyword.'/[0-9]+');
                });

            return $route;
        });
    }
1137037
protected function registerWidgets()
    {
        $default_widgets = ['LaravelAdminPanel\\Widgets\\UserDimmer', 'LaravelAdminPanel\\Widgets\\PostDimmer', 'LaravelAdminPanel\\Widgets\\PageDimmer'];
        $widgets = config('admin.dashboard.widgets', $default_widgets);

        foreach ($widgets as $widget) {
            Widget::group('admin::dimmers')->addWidget($widget);
        }
    }
995252
public function registerBladeEngine($resolver)
    {
        $app = $this->app;

        // The Compiler engine requires an instance of the CompilerInterface, which in
        // this case will be the Blade compiler, so we'll first create the compiler
        // instance to pass into the engine so it can compile the views properly.
        $app->singleton('blade.compiler', function ($app) {
            $cache = $app['config']['view.compiled'];

            return new BladeCompiler($app['files'], $cache);
        });
    }
445385
protected function bindBladeCompiler(): void
    {
        $this->app->afterResolving('blade.compiler', function (BladeCompiler $bladeCompiler) {

            // @alerts('container')
            $bladeCompiler->directive('alerts', function ($container = null) {
                if (strcasecmp('()', $container) === 0) {
                    $container = null;
                }

                return "<?php echo app('notification')->container({$container})->show(); ?>";
            });
        });
    }
501755
public function registerClassLoader() : void
    {
        if ($this->root === null) {
            return;
        }

        $path = sprintf('%s/%s/autoload.php', $this->root, $this->getVendorDirectory());

        if (!is_file($path)) {
            return;
        }

        require $path;
    }
561546
public function register()
    {
        $this->registerConfigurationMapper();
        $this->registerCacheManager();
        $this->registerEntityManager();
        $this->registerClassMetadataFactory();
        $this->registerValidationVerifier();

        $this->commands([
            'Mitch\LaravelDoctrine\Console\GenerateProxiesCommand',
            'Mitch\LaravelDoctrine\Console\SchemaCreateCommand',
            'Mitch\LaravelDoctrine\Console\SchemaUpdateCommand',
            'Mitch\LaravelDoctrine\Console\SchemaDropCommand'
        ]);
    }
911163
protected function registerEngineResolver()
    {
        $mySelf = $this;

        $this->container->bindShared('view.engine.resolver', function ($app) use ($mySelf) {
            $resolver = new EngineResolver();

            $mySelf->registerPhpEngine($resolver);
            $mySelf->registerBladeEngine($resolver);

            return $resolver;
        });
    }
967253
public function register()
    {
        $this->registerJsMinifier();
        $this->registerCssMinifier();
        $this->registerHtmlMinifier();
        $this->registerBladeMinifier();
        $this->registerMinifyCompiler();
        $this->registerHTMLMin();
    }
113990
protected function registerDirectives()
    {
        if (version_compare($this->app->version(), '5.5', '>=')) {
            // Workaround to support the PHP5.6 syntax.
            // Even tho the laravel version will lock to 7.0 >=
            // but the code is still complied and throws syntax error on 5.6.
            $blade = Blade::getFacadeRoot();
            $if    = 'if';

            foreach (['desktop', 'tablet', 'mobile'] as $key) {
                $blade->$if($key, function () use ($key) {
                    $fn = 'is' . $key;
                    return app()->make('browser-detect')->detect()->$fn();
                });
            }

            $blade->$if('browser', function ($fn) {
                return app()->make('browser-detect')->detect()->$fn();
            });
        }
    }