// similar component for re-usage
        if (file != null) {
            if (file.isAbsolute()) {
                // path was already absolute, just normalize file separator and we're done
            } else if (file.getPath().startsWith(File.separator)) {
                // drive-relative Windows path, don't align with project directory but with drive root

        }

        private final UrlNormalizer normalizer;

        UrlNormalizingPostProcessor(UrlNormalizer normalizer) {
            this.normalizer = normalizer;
        }

        @Override
        public Object execute(String expression, Object value) {
            if (value != null && URL_EXPRESSIONS.contains(expression)) {
                return normalizer.normalize(value.toString());
            }

                          {
                            "upgrade_type": "websocket"
                          }
                        ],
                        "stream_idle_timeout": "0s",
                        "normalize_path": true,
                        "request_id_extension": {
                          "typed_config": {
                            "@type": "type.googleapis.com/envoy.extensions.request_id.uuid.v3.UuidRequestIdConfig",

	// check for quoted string (string may not contain a quote)
	if match, err := regexp.MatchString("^\"[^\"]+\"$", name); err != nil {
		return err
	} else if match {
		return nil
	}

	// normalize the name to letters, digits, _ or $
	valid := true
	cleaned := strings.Map(func(r rune) rune {
		switch {
		case unicode.IsLetter(r):
			return 'a'
		case unicode.IsDigit(r):
			return '0'

      return false
    }
    if (pattern.isNullOrEmpty() ||
      pattern.startsWith(".") ||
      pattern.endsWith("..")
    ) {
      // Invalid pattern.
      return false
    }

    // Normalize hostname and pattern by turning them into absolute domain names if they are not
    // yet absolute. This is needed because server certificates do not normally contain absolute

            if (retValue.length() >= 2 && retValue.charAt(1) == '|') {
                retValue = retValue.charAt(0) + ":" + retValue.substring(2);
            }

            // normalize separators
            retValue = new File(retValue).getPath();
        }

        if (retValue == null) {
            retValue = "/";
        }
        return retValue.trim();
    }

    /**

        String configPath = form.crawlingConfigPath.trim();
        if (StringUtil.isBlank(configName)) {
            configName = StringUtils.abbreviate(configPath, 30);
        }

        // normalize
        final StringBuilder buf = new StringBuilder(1000);
        for (int i = 0; i < configPath.length(); i++) {
            final char c = configPath.charAt(i);
            if (c == '\\') {

        if (StringUtil.isBlank(fileName)) {
            throwValidationError(messages -> messages.addErrorsDesignFileNameIsNotFound("designFile"), this::asListHtml);
        }

        File uploadFile;
        // normalize filename
        if (checkFileType(fileName, fessConfig.getSupportedUploadedMediaExtentionsAsArray())
                && checkFileType(uploadedFileName, fessConfig.getSupportedUploadedMediaExtentionsAsArray())) {

        if (configParam != null) {
            final String keepOriginalBody = configParam.get(Config.KEEP_ORIGINAL_BODY);
            if (StringUtil.isNotBlank(keepOriginalBody)) {
                params.put(TikaExtractor.NORMALIZE_TEXT,
                        Constants.TRUE.equalsIgnoreCase(keepOriginalBody) ? Constants.FALSE : Constants.TRUE);
            }
        }
        return params;
    }

            dr.pathConsumed = consumed;

            /*
             * Samba has a tendency to return pathConsumed values so that they consume a trailing slash of the
             * requested path. Normalize this here.
             */
            if ( reqPath.charAt(consumed - 1) == '\\' ) {
                if ( log.isDebugEnabled() ) {
                    log.debug("Server consumed trailing slash of request path, adjusting");