if (StringUtil.isBlank(regex)) {
                    logger.warn("Unknown regex pattern: {}", entity.getTerm());
                } else {
                    pair.getSecond().add(new Pair<>(Pattern.compile(regex), entity.getContent()));
                }
            } else {
                pair.getFirst().put(toLowerCase(entity.getTerm()), entity.getContent());
            }
        });

        });
    }

    private static class DeduplicatePackageInfoFiles implements Spec<File> {

        private final Pattern pattern = Pattern.compile("package\\s*([^;\\s]+)\\s*;");

        private final Set<String> packagesSeenBefore = new HashSet<>();
        private final Set<File> canonicalPackageInfos = new HashSet<>();

        @Override

    // Patterns for sensitive data - compiled once and cached
    private static final Pattern PASSWORD_PATTERN = Pattern.compile(
            "(?i)(password|passwd|pwd|secret|token|key|credential|auth)([\"']?\\s*[:=]\\s*[\"']?)([^\"',\\s]+)", Pattern.CASE_INSENSITIVE);

    private static final Pattern IP_PATTERN = Pattern.compile("\\b(?:[0-9]{1,3}\\.){3}[0-9]{1,3}\\b");

    // Object pools for performance optimization

     * @param content The content to search.
     * @return The extracted token value.
     */
    protected String getTokenValue(final String tokenPattern, final String content) {
        final Matcher matcher = Pattern.compile(tokenPattern).matcher(content);
        if (matcher.find()) {
            if (logger.isDebugEnabled()) {
                logger.debug("Matched: {}", matcher.group());
            }

                        || Artifact.SCOPE_PROVIDED.equals(nearestArtifact.getScope()))) {
            updateScope = true;
        }

        /* farthest is compile and nearest is not (has lower priority), change to compile */
        if (Artifact.SCOPE_COMPILE.equals(farthestArtifact.getScope())
                && !Artifact.SCOPE_COMPILE.equals(nearestArtifact.getScope())) {
            updateScope = true;

 *      <td>Flags this Mojo as requiring the dependencies in the specified scope (or an implied scope) to be
 *          resolved before it can execute.
 *          <br>
 *          <i>NOTE: Currently supports <b>compile</b>, <b>runtime</b>, and <b>test</b> scopes.</i>
 *      </td>
 *   </tr>
 *   <tr>
 *      <td>description</td>
 *      <td>none (detected)</td>
 *      <td>No</td>

          <description>
            All the sources to compile and resources files to copy for a project or it's unit tests.
            The sources can be Java source files, generated source files, scripts, or resources for examples.
            Each source is specified by a {@code directory} element, which is relative to the POM.
            The kind of sources (source files to compile or resources to copy) and their usage (for the main code

import org.gradle.api.tasks.PathSensitivity
import org.gradle.api.tasks.SourceSet
import org.gradle.api.tasks.SourceSetContainer
import org.gradle.api.tasks.TaskProvider
import org.gradle.api.tasks.compile.GroovyCompile
import org.gradle.kotlin.dsl.*
import org.gradle.plugins.ide.idea.IdeaPlugin
import org.gradle.process.CommandLineArgumentProvider


fun Project.addDependenciesAndConfigurations(prefix: String) {

            } catch (LookupException e) {
                names = List.of(
                        "clean",
                        "validate",
                        "compile",
                        "test",
                        "package",
                        "verify",
                        "install",
                        "deploy",
                        "wrapper:wrapper");

     * Example: <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
     */
    protected Pattern metaCharsetPattern = Pattern.compile("<meta.*content\\s*=\\s*['\"].*;\\s*charset=([\\w\\d\\-_]*)['\"]\\s*/?>",
            Pattern.MULTILINE | Pattern.CASE_INSENSITIVE);

    /**
     * Map of features for the DOM parser.
     */