Looks for $path within pre-resolved paths for provided design.
If it cannot be found, fallbacks to original resolver.

{@inheritdoc}
764692
public function resolveAssetPath($path, $design)
    {
        if (!isset($this->resolvedPaths[$design][$path])) {
            return $this->innerResolver->resolveAssetPath($path, $design);
        }

        return $this->resolvedPaths[$design][$path];
    }
1079407
private function locateUsingRootPlaceholder(string $path): ?string
    {
        if (0 !== mb_strpos($path, '@') || 1 !== preg_match('{^@(?<name>[^:]+):(?<path>.+)$}', $path, $match)) {
            return null;
        }

        if (isset($this->roots[$match['name']])) {
            return $this->generateAbsolutePath($this->roots[$match['name']], $match['path']);
        }

        throw new NotLoadableException(sprintf('Invalid root placeholder "@%s" for path "%s"',
            $match['name'], $match['path']));
    }
774056
public static function resolve_path_with_dots($path) {

		if(!is_null($path) && is_string($path) && strlen($path)) {
			while(preg_match('/\/\//', $path)) {
				$path = preg_replace('/\/\//', '/', $path);
			}
			$retval = $path;
			if(preg_match('/\./', $path)) {

				$isAbsolute = FALSE;
				if(preg_match('/^\//', $path)) {
					$isAbsolute = TRUE;
					$path = preg_replace('/^\//', '', $path);
				}
				$pieces = explode('/', $path);

				$finalPieces = array();
				for($i=0; $i < count($pieces); $i++) {
					$dirName = $pieces[$i];
					if($dirName == '.') {
						//do nothing; don't bother appending.
					}
					elseif($dirName == '..') {
						array_pop($finalPieces);
					}
					else {
						$finalPieces[] = $dirName;
					}
				}

				//$retval = cs_global::string_from_array($finalPieces, NULL, '/');
				$retval = implode('/', $finalPieces);
				if($isAbsolute) {
					$retval = '/'. $retval;
				}
			}
		}
		else {
			throw new \InvalidArgumentException(__METHOD__ .": invalid path (". $path .")");
		}

		if(is_null($retval)) {
			throw new \LogicException(__METHOD__ .": returning NULL for path (". $path .")");
		}
		return($retval);
	}
524582
function resolve(path, root, resolver) {
  try {
    // Add a default value to each path part lacking a prefix.
    let nspath = path.replace(/\/(?!\.)([^\/:\(]+)(?=\/|$)/g, '/_default_:$1')
    return platformResolve(nspath, root, resolver)
  } catch (err) {
    return fallbackResolve(path, root)
  }
}
1315120
function resolvePaths(paths) {
  var exec = {};
  var originalWd = process.cwd();
  for (var name in paths) {
    process.chdir(originalWd);
    exec[name] = resolveLink(paths[name]);
    process.chdir(originalWd);
  }
  process.chdir(originalWd);
  return exec;
}
698719
protected function resolvePath()
    {
        if (!isset($this->server['REQUEST_URI'])) {
            return null;
        }

        $url = $this->server['REQUEST_URI'];

        if (false !== $queryStart = strpos($url, '?')) {
            $url = substr($url, 0, $queryStart);
        }

        $url = preg_replace('/^' . preg_quote($this->dir, '/') . '/', null, $url);
        $url = '/' . trim($url, '/');

        return $url;
    }
89064
public function path($path = null)
    {
        if (!func_num_args()) {
            return $this->_path;
        }
        $this->_path = '/' . ltrim($path, '/');
        return $this;
    }
240604
public static function resolve($path)
    {
        if (empty($path)) {
            return false;
        }

        $path = Uri::canonpath($path);

        if ($path . '/' === self::path() || strpos($path, self::path()) === 0) {
            return $path;
        }

        return self::path() . $path;
    }
471607
private function resolvePath(array $value, string $path)
    {
        $path = preg_replace('/\[(.*?)\]/', '.$1', $path);
        $path = explode('.', $path);

        foreach ($path as $item) {
            if (is_array($value) && isset($value[$item])) {
                $value = $value[$item];
            } else {
                return null;
            }
        }

        return $value;
    }
958116
static Path resolvePath(final Path base, final String... paths) {
        return Paths.get(base.toString(), paths);
    }
1041455
public function resolve($path)
    {
        $path = str_replace('/', '.', preg_replace('/\/:\w+/', '', $path));

        $finder = $this->container['view.finder'];

        try {
            $finder->find($path);
        } catch (InvalidArgumentException $e) {
            $explodedPath = explode('.', $path);


            if ($explodedPath[0] === 'static') {
                return null;
            }

            if (count($explodedPath) > 1) {
                $explodedPath[0] = 'shared';
                $explodedPath = array('shared', end($explodedPath));
                try {
                    $finder->find(implode('.', $explodedPath));
                    $path = implode('.', $explodedPath);
                } catch (InvalidArgumentException $e) {
                    $this->app->error($e);
                }
            }
        }

        return $path;
    }
836040
private function resolveValidPath():string{
		$last = null;
		foreach( $this->tree as $level ){
			if( !$level->exist ){
				break;
			}
			$last = $level;
		}
		if( $last === null ){
			return '';
		}
		return $last->path;
	}
1242437
public function resolvePath($value)
    {
        do {
            $value = $this->getValueByPath($value);
        } while (self::isPath($value));

        return $value;
    }
513
public function determineExistingSchemaSearchPaths()
    {
        $names = $this->getSchemaNames();
        $paths = $this->getSchemaSearchPaths();

        $this->existingSchemaPaths = array_filter($paths, static function ($v) use ($names) {
            return in_array($v, $names);
        });
    }
620799
function getPath(parent, unresolved) {
	let parentVisited = false;

	return Object.keys(unresolved).filter((module) => {
		if (module === parent) {
			parentVisited = true;
		}
		return parentVisited && unresolved[module];
	});
}
257972
private function resolveLocalPath($path, $baseFolder)
    {
        $path = $this->filesystem->normalizePath($path);
        if ($this->filesystem->isAbsolutePath($path)) {
            return $path;
        }
        if (stripos($baseFolder, 'file://') === 0) {
            $baseFolder = substr($baseFolder, 7);
        }
        $baseFolder = $this->filesystem->normalizePath($baseFolder);

        return $baseFolder.'/'.$path;
    }
644449
public static function resolveExtensionPath($callerImport, $parser, $syntax='scss')
	{
		$alias=str_replace('/_', '/', str_replace(array('.scss', '.sass'), '', $callerImport));
		if (strrpos($alias, '/')!==FALSE) {
			$alias=substr($alias, strrpos($alias, '/')+1);
			}
		if (self::$filePaths==NULL) {
			self::$filePaths=self::getFilesArray(__DIR__.'/'.self::$filesFolder.'/');
			}
		if (isset(self::$filePaths[$alias])) {
			return self::$filePaths[$alias];
			}
	}