protected String getFilePath(final String url) {
        return url.replaceAll("/+", "/")
                .replace("./", "")
                .replace("../", "")
                .replaceAll("/$", "/index.html")
                .replaceAll("\\?", questionStr)
                .replaceAll(":", colonStr)
                .replaceAll(";", semicolonStr)
                .replaceAll("&", ampersandStr);
    }

    /**

        String rewritten = document.body().html();
        // Turn Gradle Jira issue numbers into issue links
        rewritten = rewritten.replaceAll("GRADLE-\\d+", "<a href=\"https://issues.gradle.org/browse/$0\">$0</a>");
        // Turn Gradle Github issue numbers into issue links
        rewritten = rewritten.replaceAll("(gradle/[a-zA-Z\\-_]+)#(\\d+)", "<a href=\"https://github.com/$1/issues/$2\">$0</a>");
        document.body().html(rewritten);
    }

                buf.append('\t').append("action:begin");
                buf.append('\t').append("error:").append(escapeValue(e.getLocalizedMessage()).replaceAll("\\s", " "));
                log(buf);
            }
        });
    }

    /**
     * Records a statistics action for the specified crawler object.
     *

	// convert single quote into double quote
	sql = strings.ReplaceAll(sql, `'`, `"`)

	// convert dialect special quote into double quote
	switch DB.Dialector.Name() {
	case "postgres", "gaussdb":
		sql = strings.ReplaceAll(sql, `"`, `"`)
	case "mysql", "sqlite":
		sql = strings.ReplaceAll(sql, "`", `"`)
	case "sqlserver":
		sql = strings.ReplaceAll(sql, `'`, `"`)
	}

	return sql

            } else if (lowerPath.endsWith("/")) {
                response.setContentType("text/html;charset=utf-8");
            }
        }

        Path filePath = ResourceUtil.getSitePath(path.replaceAll("\\.\\.+", StringUtil.EMPTY).replaceAll("/+", "/").split("/"));
        if (Files.isDirectory(filePath)) {
            filePath = filePath.resolve("index.html");
        }
        if (Files.exists(filePath)) {

     */
    public static String replace(final Object input, final String regex, final String replacement) {
        if (input == null) {
            return StringUtil.EMPTY;
        }
        return input.toString().replaceAll(regex, replacement);
    }

    /**
     * Formats code content with syntax highlighting and line numbers.
     *
     * @param prefix the line number prefix pattern

        // 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);

        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 {

                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;
        }