* and reduces code duplication across strategy implementations.
 *
 * <p>Strategies work with domtrip Documents for perfect formatting preservation.
 * Subclasses can create domtrip Editors from Documents as needed:
 * <pre>
 * Editor editor = new Editor(document);
 * // ... perform domtrip operations ...
 * // Document is automatically updated
 * </pre>
 */
public abstract class AbstractUpgradeStrategy implements UpgradeStrategy {

                    <version>1.0.0</version>
                </project>
                """;

            Document document = Document.of(pomXml);
            ModelVersionUtils.updateModelVersion(document, targetVersion);
            Element root = document.root();
            Element modelVersionElement = root.child("modelVersion").orElse(null);
            assertNotNull(modelVersionElement);

                    <artifactId>child-project</artifactId>
                </project>
                """;

            Document parentDoc = Document.of(parentPomXml);
            Document childDoc = Document.of(childPomXml);

            Map<Path, Document> pomMap = new HashMap<>();
            pomMap.put(Paths.get("/project/pom.xml"), parentDoc);

    document.querySelectorAll(".use-termynal").forEach(node => {
        node.style.display = "block";
        new Termynal(node, {
            lineDelay: 500
        });
    });
    const progressLiteralStart = "---> 100%";
    const promptLiteralStart = "$ ";
    const customPromptLiteralStart = "# ";
    const termynalActivateClass = "termy";
    let termynals = [];

    function createTermynals() {
        document

    private final Document document;
    private final JavadocLinkConverter linkConverter;

    public JavadocConverter(Document document, JavadocLinkConverter linkConverter) {
        this.document = document;
        this.linkConverter = linkConverter;
    }

    private final String javaVersion;

    public LinkRenderer(Document document, DslDocModel model, String groovyVersion, String javaVersion) {
        this.document = document;
        this.model = model;
        this.groovyVersion = groovyVersion;
        this.javaVersion = javaVersion;
        primitiveTypes.add("boolean");
        primitiveTypes.add("byte");
        primitiveTypes.add("short");
        primitiveTypes.add("int");

                </project>
                """;

            Document document = Document.of(pomXml);
            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);

            UpgradeContext context = createMockContext();
            strategy.doApply(context, pomMap);

            // Verify the structure
            Editor editor = new Editor(document);
            Element root = editor.root();

     * @return a map of Path to Document for all discovered POM files
     * @throws IOException if there's an error reading files
     * @throws DomTripException if there's an error parsing XML
     */
    public static Map<Path, Document> discoverPoms(Path startDirectory) throws IOException, DomTripException {
        Map<Path, Document> pomMap = new HashMap<>();

        // Find and load the root POM

        return xml.toString();
    }

    public Document buildDocument() {
        try {
            String xmlContent = build();
            Editor editor = new Editor(Document.of(xmlContent));
            return editor.document();
        } catch (Exception e) {
            throw new RuntimeException("Failed to build POM document", e);
        }
    }

                    </dependencies>
                </project>
                """;

            Document parentDoc = Document.of(parentPomXml);
            Document moduleADoc = Document.of(moduleAPomXml);
            Document moduleBDoc = Document.of(moduleBPomXml);

            Map<Path, Document> pomMap = new HashMap<>();
            pomMap.put(Paths.get("project", "pom.xml"), parentDoc);