return ipv6Address;
        }

        // Normalize each part (remove leading zeros)
        final String[] normalized = new String[8];
        for (int i = 0; i < 8; i++) {
            normalized[i] = parts[i].replaceFirst("^0+(?!$)", "");
            if (normalized[i].isEmpty()) {
                normalized[i] = "0";
            }
        }

import javax.inject.Named;
import javax.inject.Singleton;

/**
 * Normalizes a URL.
 *
 * @deprecated use {@code org.apache.maven.api.services.ModelBuilder} instead
 */
@Named
@Singleton
@Deprecated(since = "4.0.0")
public class DefaultUrlNormalizer implements UrlNormalizer {

    @Override
    public String normalize(String url) {
        String result = url;

        if (result != null) {

        return directory;
    }

    /**
     * Resolves against current cwd, resulting path is normalized.
     *
     * @throws NullPointerException if {@code seg} is {@code null}.
     */
    @Nonnull
    public Path resolve(String seg) {
        requireNonNull(seg, "seg");
        return directory.resolve(seg).normalize();
    }

    /**
     * Changes current cwd, if the new path is existing directory.
     *

        }
    }

    /**
     * Validates and normalizes SMB path
     *
     * @param path the path to normalize
     * @return normalized path
     */
    public static String normalizeSmbPath(String path) {
        validateSmbPath(path);

        // Normalize slashes
        path = path.replace('/', '\\');

        // Remove redundant slashes

            return buf.toString();
        } catch (final UnsupportedEncodingException e) {
            return path;
        }
    }

    /**
     * Normalizes a configuration path.
     *
     * @param path The path to normalize.
     * @return The normalized path.
     */
    public String normalizeConfigPath(final String path) {

        if (StringUtil.isBlank(path)) {
            return StringUtils.EMPTY;

        }
        final int maxLength = ComponentUtil.getFessConfig().getScriptAuditLogMaxLengthAsInteger();
        String normalized = script;
        if (normalized.length() > maxLength) {
            normalized = normalized.substring(0, maxLength - 3) + "...";
        }
        return normalized.replace('\n', ' ').replace('\r', ' ').replace('\t', '_');
    }

    /**
     * Log the access denied activity.

        String url = "smb://server/share/folder/file.txt";
        String normalized = validator.validateSmbUrl(url);
        assertTrue(normalized.startsWith("smb://"));
        assertTrue(normalized.contains("server"));
        assertTrue(normalized.contains("/share/folder/file.txt") || normalized.contains("\\share\\folder\\file.txt"));
    }

    @Test

     * Truncates and normalizes content to create a summary suitable for display.
     *
     * @param responseData the response data from crawling (not currently used)
     * @param content the content to create a digest from
     * @param dataMap additional data map (not currently used)
     * @param maxWidth the maximum width of the digest
     * @return the abbreviated and normalized digest, or empty string if content is null

		}
		res[userDistName] = set.CreateStringSet(groups...)
	}

	return res, nil
}

// QuickNormalizeDN - normalizes the given DN without checking if it is valid or
// exists in the LDAP directory. Returns input if error
func (l Config) QuickNormalizeDN(dn string) string {
	if normDN, err := xldap.NormalizeDN(dn); err == nil {
		return normDN
	}
	return dn
}

  while (!bufferA.exhausted()) {
    val codePoint = bufferA.readUtf8CodePoint()
    if (!IDNA_MAPPING_TABLE.map(codePoint, bufferB)) return null
  }

  // 2. Normalize, from bufferB to bufferA.
  val normalized = normalizeNfc(bufferB.readUtf8())
  bufferA.writeUtf8(normalized)

  // 3. For each label, convert/validate Punycode.
  val decoded = Punycode.decode(bufferA.readUtf8()) ?: return null

  // 4.1 Validate.