// Replace forward slashes with backslashes for consistency
        String normalized = path.replace('/', '\\');

        // Remove duplicate slashes
        normalized = normalized.replaceAll("\\\\+", "\\\\");

        // Remove trailing slash unless it's the root
        if (normalized.length() > 1 && normalized.endsWith("\\")) {
            normalized = normalized.substring(0, normalized.length() - 1);

     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public ActionResponse download(final String id) {
        final String filename = new String(Base64.getDecoder().decode(id), StandardCharsets.UTF_8).replace("..", "").replaceAll("\\s", "");
        final String logFilePath = systemHelper.getLogFilePath();
        if (StringUtil.isNotBlank(logFilePath) && isLogFilename(filename)) {
            final Path path = Paths.get(logFilePath, filename);

                pos--;
            }

            value = escaped.substring(pos + 1);
        } else {
            value = escaped;
        }
        return value.replaceAll(escapedHighlightPre, highlightTagPre).replaceAll(escapedHighlightPost, highlightTagPost);
    }

    /**
     * Removes highlight tags from a string.
     *
     * @param str the string containing highlight tags

        validateSmbPath(path);

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

        // Remove redundant slashes
        path = path.replaceAll("\\\\+", "\\\\");

        // Remove trailing slash unless it's root
        if (path.length() > 1 && path.endsWith("\\")) {
            path = path.substring(0, path.length() - 1);
        }

func (ls *LiteralString) Capture(values []string) error {
	// Remove enclosing single quote
	n := len(values[0])
	r := values[0][1 : n-1]
	// Translate doubled quotes
	*ls = LiteralString(strings.ReplaceAll(r, "''", "'"))
	return nil
}

// LiteralList is a type for parsed SQL lists literals
type LiteralList []string

// Capture interface used by participle
func (ls *LiteralList) Capture(values []string) error {

        String value = request.getParameter("type");
        if (value == null) {
            final String servletPath = request.getServletPath();
            final String[] values = servletPath.replaceAll("/+", "/").split("/");
            if (values.length > 2) {
                value = values[2];
            }
        }
        if (value == null) {
            return FormatType.SEARCH;
        }

	if list == nil {
		return t
	}
	list.RLock()
	defer list.RUnlock()
	t.TargetStats = make(map[string]TargetStat, len(list.targets))
	for id, target := range list.targets {
		t.TargetStats[strings.ReplaceAll(id.String(), ":", "_")] = target.Stat()
	}
	return t
}

// NewTargetList - creates TargetList.
func NewTargetList() *TargetList {
	return &TargetList{targets: make(map[TargetID]Target)}

	}

	id := uuid.MustParse(deploymentID)

	if file != "" {
		distrib := make([][]string, setCount)
		b, err := os.ReadFile(file)
		if err != nil {
			log.Fatalln(err)
		}
		b = bytes.ReplaceAll(b, []byte("\r"), []byte{})
		sc := bufio.NewScanner(bytes.NewBuffer(b))
		for sc.Scan() {
			object = strings.TrimSpace(sc.Text())
			set := sipHashMod(prefix+object, setCount, id)

                return data; // No sensitive patterns detected, skip regex
            }
        }

        // Mask passwords and secrets using cached pattern
        return PASSWORD_PATTERN.matcher(data).replaceAll("$1$2****");
    }

    private Map<String, Object> maskContext(Map<String, Object> context) {
        if (!maskSensitiveData) {
            return context;
        }

                extention = strings[strings.length - 1];
            } else {
                filePrefix = name;
                extention = "";
            }
            filePrefix = filePrefix.replaceAll("\\p{Zs}", "_");
        } else {
            filePrefix = "none";
            extention = "";
        }
        File inputFile = null;
        File outputFile = null;
        try {