Return true if the route contains dynamic parts
492220
def is_dynamic(self):
        '''  '''
        if not self._static:
            for token, value in self.tokens():
                if token != 'TXT':
                    return True
        self._static = True
        return False
441433
protected function processRoute(): bool
    {
        $uri = $this->getCleanUri();
        $uri = trim($uri, '/');
        $raw = explode('/', $uri);

        // rewrite module from request
        if (\count($raw)) {
            $this->setParam('_module', array_shift($raw));
        }
        // rewrite module from controller
        if (\count($raw)) {
            $this->setParam('_controller', array_shift($raw));
        }
        if ($size = \count($raw)) {
            // save raw
            $this->rawParams = $raw;

            // save as index params
            foreach ($raw as $i => $value) {
                $this->setParam($i, $value);
            }

            // remove tail
            if ($size % 2 === 1) {
                array_pop($raw);
                $size = \count($raw);
            }
            // or use array_chunk and run another loop?
            for ($i = 0; $i < $size; $i += 2) {
                $this->setParam($raw[$i], $raw[$i + 1]);
            }
        }
        return true;
    }
45157
public function isMaintain()
    {
        if (file_exists(route()->root.'maintained')) {
            return true;
        } elseif (__config()->config->maintenance) {
            return true;
        } else {
            return false;
        }
    }
869641
function canRoute(url) {
	for (let i=ROUTERS.length; i--; ) {
		if (ROUTERS[i].canRoute(url)) return true;
	}
	return false;
}
1314309
function areRoutesShallowEqual(one, two) {
  if (!one || !two) {
    return one === two;
  }

  if (one.key !== two.key) {
    return false;
  }

  return shallowEqual(one, two);
}
453415
function (params, route) {
                // Due to how our routing accepts arbitrary length folders 
                // The key param could be split between params.key and params.'0'
                // Return the combined keys
                var restOfKey = params['0'] || '';

                var key = params.key + restOfKey;

                // Check if this route ends with a / ensure the key also does (similar to strict routing)
                if (route.path.slice(-1) === '/' && key.slice(-1) !== '/') {
                    key = key + '/';
                }

                return key;
            }
296490
private function isExcluded($route)
    {
        $uri = $this->getRouteParam($route, 'uri');
        $actionController = $this->getRouteParam($route, 'action.controller');
        
        return $this->isExcludedClass($actionController) || $this->isExcludedRoute($uri);
    }
605773
function compareUrlRoute(currentURL, currentRoute) {
                var regex = /\{(.*)\}/i;
                var arraySize = currentRoute.length,
                    testValue = false;
                for (var i = 0; i < arraySize; i++) {
                    var dynamic = regex.exec(currentRoute[i]);
                    if (dynamic) {
                        document.routeParams[dynamic[1]] = currentURL[i];
                    } else {
                        if (currentRoute[i] === currentURL[i]) {
                            testValue = true;
                        }
                    }
                }

                return testValue;
            }
82454
public function match($route, $method = 'GET', $options = [])
    {
        $route = RouteHelper::normalise($route);

        $this->count = 0;

        $this->buildRouteMaps();

        $keys = array_keys($this->routeMaps);

        $left = 0;
        $right = count($this->routeMaps) - 1;

        while ($left <= $right) {
            $middle = round(($left + $right) / 2);
            $key = $keys[$middle];
            $routeItem = $this->routes[$this->routeMaps[$key]];

            $this->count++;

            if ($this->matchOptions($routeItem, $method, $options) && $this->matchRoute($route, $routeItem)) {
                return $routeItem;
            }

            if (strcmp($route, $key) < 0) {
                $right = $middle - 1;
            } else {
                $left = $middle + 1;
            }
        }

        return false;
    }
628086
def _has_fr_route(self):
        """"""
        # 404's, 405's, which might not have a url_rule
        if self._should_use_fr_error_handler():
            return True
        # for all other errors, just check if FR dispatched the route
        if not request.url_rule:
            return False
        return self.owns_endpoint(request.url_rule.endpoint)
699901
protected function hasShouldRouteGroup($request): bool
    {
        if (!config('cors.laravel.route-group-mode')) {
            return true;
        }

        $shouldClsssName = ShouldGroup::class;
        $shouldAlias = collect(Route::getMiddleware())->flip()->get($shouldClsssName, $shouldClsssName);
        $route = collect(Route::getRoutes()->get())->first(function ($route) use ($request) {
            return $route->matches($request, false);
        });
        if (!$route) {
            return false;
        }
        $gatherMiddleware = $route->gatherMiddleware();

        if (in_array($shouldClsssName, $gatherMiddleware) || in_array($shouldAlias, $gatherMiddleware)) {
            return true;
        }

        $middlewareGroups = collect(Route::getMiddlewareGroups())->filter(function ($group) use ($shouldClsssName, $shouldAlias) {
            return in_array($shouldAlias, $group) || in_array($shouldClsssName, $group);
        })->keys();

        return $middlewareGroups->filter(function ($value) use ($gatherMiddleware) {
            return in_array($value, $gatherMiddleware);
        })->isNotEmpty();
    }
975503
function _checkForDynamicPage(uri, { _dynamic }) {
  if (!_dynamic || typeof _dynamic !== 'boolean') {
    return bluebird.reject(new Error('Page is not dynamic and requires a url'));
  }

  return bluebird.resolve(_dynamic);
}
436311
def get_routes(self, viewset):
        
        routes = super(DynamicRouter, self).get_routes(viewset)
        routes += self.get_relation_routes(viewset)
        return routes
25795
function(obj, parts) {
    if (parts.length === 0) { return true; }
    
    var key = parts.shift();

    if (!_(obj).has(key)) {
      return false;
    } else {
      return hasKeyPath(obj[key], parts);
    }
  }
1023258
protected function isValidRoute()
    {
        try {

            $current = Route::current();
            if (!$current) {
                return false;
            }
            $action = $current->action;
            $as     = array_get($action, 'as');
            return str_contains($as, 'show') or str_contains($as, 'dashboard');
        } catch (Exception $ex) {
            return false;
        }
    }
282509
private function matchExact(): bool
    {
        foreach ($this->routesExact as $route) {
            if ($this->uri === $route['u']) { // compare the current URI array to this route URI array
                $this->control = $route['c']; // set control or this exact match

                return true; // exact match found
            }
        }

        return false; // exact match not found
    }
1216877
public function has_subparts() {
        foreach ($this->get_variant_nos() as $variantno) {
            if (count($this->get_subpart_ids($variantno)) > 1) {
                return true;
            }
        }
        return false;
    }