@ethlete/core 5.0.0-next.7 → 5.0.0-next.70

package/generators/migrate-to-v5/viewport-service.js

@@ -1,74 +1,41 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { logger } from '@nx/devkit';
 import * as ts from 'typescript';
-export default async function migrateViewportService(tree) {
-    logger.log('\n🔄 Migrating ViewportService to standalone utilities...\n');
-    const tsFiles = [];
-    const styleFiles = [];
-    // Collect all TypeScript and style files
-    function findFiles(dir) {
-        const children = tree.children(dir);
-        for (const child of children) {
-            const path = dir === '.' ? child : `${dir}/${child}`;
-            if (tree.isFile(path)) {
-                if (path.endsWith('.ts') && !path.includes('node_modules') && !path.includes('.spec.ts')) {
-                    tsFiles.push(path);
-                }
-                else if (path.endsWith('.css') ||
-                    path.endsWith('.scss') ||
-                    path.endsWith('.sass') ||
-                    path.endsWith('.less')) {
-                    styleFiles.push(path);
-                }
-            }
-            else {
-                findFiles(path);
-            }
-        }
-    }
-    findFiles('.');
-    // Detect which CSS variables are being used across the codebase
-    const cssVariablesUsed = detectCssVariableUsage(tree, styleFiles);
+import { collectFiles } from './migration-files.js';
+import { findSyncObservableConsumers } from './sync-observable-consumers.js';
+import { applyReplacementsInClass, collectClasses, findServiceClasses, getServiceImport, isServiceParameter, isServiceProperty, isServiceStillUsed, removeServiceImport, } from './service-classes.js';
+export default async function migrateViewportService(tree, scope) {
+    const tsFiles = collectFiles(tree, scope, ['.ts']);
+    const review = [];
     let filesModified = 0;
     let templatesModified = 0;
-    let viewportServiceUsed = false;
-    // Track which properties became signals for template migration
-    const componentTemplateMigrations = new Map();
-    // Process each TypeScript file
+    const externalTemplateMigrations = new Map();
     for (const filePath of tsFiles) {
         const content = tree.read(filePath, 'utf-8');
         if (!content)
             continue;
-        // Skip files that don't use ViewportService
         if (!content.includes('ViewportService'))
             continue;
-        logger.log(`Processing: ${filePath}`);
         const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-        // Check if this is a component with a template
-        const templatePath = findTemplateForComponent(tree, filePath, sourceFile);
-        // Track signal properties for template migration
-        const templateMigrationInfo = {
-            signalProperties: new Set(),
-        };
-        // First handle inline inject patterns (e.g., toSignal(inject(ViewportService).isXs$))
-        const inlineResult = handleInlineInjectPatterns(sourceFile, content);
+        const serviceImport = getServiceImport(sourceFile, 'ViewportService');
+        const viewportPackage = serviceImport?.packageName;
+        if (!serviceImport || (viewportPackage !== '@ethlete/core' && !viewportPackage?.startsWith('@fifa-gg/uikit'))) {
+            continue;
+        }
+        const serviceName = serviceImport.localName;
+        const inlineResult = handleInlineInjectPatterns(sourceFile, content, serviceName);
         let updatedContent = inlineResult.content;
-        // Re-parse if content changed
         const updatedSourceFile = updatedContent !== content
             ? ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true)
             : sourceFile;
-        // Find all ViewportService variables (injected or constructor params)
-        const viewportServiceVars = findViewportServiceVariables(updatedSourceFile);
+        const viewportServiceVars = findViewportServiceVariables(updatedSourceFile, serviceName);
+        const serviceClasses = findServiceClasses(updatedSourceFile, serviceName);
         if (viewportServiceVars.length === 0 && inlineResult.importsNeeded.size === 0) {
             continue;
         }
-        viewportServiceUsed = true;
         const allImportsNeeded = {
             '@ethlete/core': new Set(),
             '@angular/core/rxjs-interop': new Set(),
         };
-        // Merge imports from inline patterns
         for (const importName of inlineResult.importsNeeded) {
             if (importName === 'toObservable' || importName === 'toSignal') {
                 allImportsNeeded['@angular/core/rxjs-interop'].add(importName);
@@ -77,270 +44,174 @@ export default async function migrateViewportService(tree) {
                 allImportsNeeded['@ethlete/core'].add(importName);
             }
         }
-        // Process each ViewportService variable found in the file
-        for (const viewportServiceVar of viewportServiceVars) {
-            const classNode = findClassForViewportService(updatedSourceFile, viewportServiceVar);
-            if (!classNode)
-                continue;
-            // Analyze what needs to be migrated BEFORE making any changes
-            const context = analyzeClassMigration(updatedSourceFile, classNode, viewportServiceVar);
-            // Track imports needed from direct replacements
-            context.importsNeeded.forEach((imp) => allImportsNeeded['@ethlete/core'].add(imp));
-            // Track imports needed from new members
-            context.membersToAdd.forEach((member) => {
-                allImportsNeeded['@ethlete/core'].add(member.injectFn);
-                if (member.type === 'observable' && !member.wrappedInToSignal) {
-                    allImportsNeeded['@angular/core/rxjs-interop'].add('toObservable');
-                }
-            });
-            // Check if any replacements use toObservable or toSignal
-            for (const [original, replacement] of context.replacements) {
-                if (replacement.includes('toObservable(')) {
-                    allImportsNeeded['@angular/core/rxjs-interop'].add('toObservable');
-                }
-                if (replacement.includes('toSignal(')) {
-                    allImportsNeeded['@angular/core/rxjs-interop'].add('toSignal');
+        for (const { index, fields } of serviceClasses) {
+            for (const viewportServiceVar of fields) {
+                const currentSourceFile = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
+                const classNode = collectClasses(currentSourceFile)[index];
+                const context = analyzeClassMigration(currentSourceFile, classNode, viewportServiceVar);
+                context.importsNeeded.forEach((imp) => allImportsNeeded['@ethlete/core'].add(imp));
+                context.membersToAdd.forEach((member) => {
+                    allImportsNeeded['@ethlete/core'].add(member.injectFn);
+                    if (member.type === 'observable' && !member.wrappedInToSignal) {
+                        allImportsNeeded['@angular/core/rxjs-interop'].add('toObservable');
+                    }
+                });
+                for (const replacement of context.replacements.values()) {
+                    if (replacement.includes('toObservable(')) {
+                        allImportsNeeded['@angular/core/rxjs-interop'].add('toObservable');
+                    }
+                    if (replacement.includes('toSignal(')) {
+                        allImportsNeeded['@angular/core/rxjs-interop'].add('toSignal');
+                    }
                 }
-            }
-            // Apply replacements FIRST (before adding members)
-            for (const [original, replacement] of context.replacements) {
-                const regex = new RegExp(escapeRegExp(original), 'g');
-                updatedContent = updatedContent.replace(regex, replacement);
-            }
-            // Then add new members to the updated content
-            if (context.membersToAdd.length > 0) {
-                const sourceFileUpdated = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
-                const classNodeUpdated = findClassForViewportService(sourceFileUpdated, viewportServiceVar);
-                if (classNodeUpdated) {
-                    updatedContent = addMembersToClass(sourceFileUpdated, updatedContent, classNodeUpdated, context.membersToAdd, viewportServiceVar);
+                updatedContent = applyReplacementsInClass(updatedContent, currentSourceFile, classNode, context.replacements);
+                if (context.membersToAdd.length > 0) {
+                    const sourceFileUpdated = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
+                    updatedContent = addMembersToClass(sourceFileUpdated, updatedContent, collectClasses(sourceFileUpdated)[index], context.membersToAdd, viewportServiceVar);
                 }
             }
         }
-        // Handle monitorViewport migrations
         const sourceFileAfterReplacements = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
-        const monitorViewportResult = migrateMonitorViewport(sourceFileAfterReplacements, updatedContent, viewportServiceVars, cssVariablesUsed);
+        const monitorViewportResult = migrateMonitorViewport(sourceFileAfterReplacements, updatedContent, viewportServiceVars);
         updatedContent = monitorViewportResult.content;
         monitorViewportResult.imports.forEach((imp) => allImportsNeeded['@ethlete/core'].add(imp));
-        // Add necessary imports
         for (const [packageName, importsSet] of Object.entries(allImportsNeeded)) {
             if (importsSet.size > 0) {
                 const sourceFileUpdated = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
                 updatedContent = addImportsToPackage(sourceFileUpdated, updatedContent, importsSet, packageName);
             }
         }
-        // Remove ViewportService injection (properties and constructor params)
         const sourceFileFinal = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
-        updatedContent = removeViewportServiceInjection(sourceFileFinal, updatedContent, viewportServiceVars, filePath);
-        // Remove ViewportService import if no longer needed
+        updatedContent = removeViewportServiceInjection(sourceFileFinal, updatedContent, serviceName, filePath);
         const sourceFileAfterRemoval = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
-        if (!checkIfViewportServiceStillUsed(sourceFileAfterRemoval, viewportServiceVars)) {
-            updatedContent = removeViewportServiceImport(sourceFileAfterRemoval, updatedContent);
+        if (isServiceStillUsed(sourceFileAfterRemoval, serviceName, serviceClasses)) {
+            review.push(`${filePath}: ViewportService is still used. Migrate the remaining usages manually.`);
+        }
+        else {
+            updatedContent = removeServiceImport(sourceFileAfterRemoval, updatedContent, 'ViewportService');
         }
-        // Clean up unused imports (toSignal, toObservable)
         const sourceFileAfterCleanup = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
         updatedContent = removeUnusedImports(sourceFileAfterCleanup, updatedContent);
-        // Always collect signalProperties for this file
-        const updatedSourceFileForSignals = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
-        updatedSourceFileForSignals.forEachChild((node) => {
-            if (ts.isClassDeclaration(node)) {
-                node.members.forEach((member) => {
-                    if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name)) {
-                        const memberName = member.name.text;
-                        const isPublicOrProtected = !member.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.PrivateKeyword);
-                        if (isPublicOrProtected && member.initializer) {
-                            const initText = member.initializer.getText(updatedSourceFileForSignals);
-                            // Check if this property uses any of our inject functions (which return signals)
-                            const usesSignalInject = initText.includes('injectIsXs()') ||
-                                initText.includes('injectIsSm()') ||
-                                initText.includes('injectIsMd()') ||
-                                initText.includes('injectIsLg()') ||
-                                initText.includes('injectIsXl()') ||
-                                initText.includes('injectIs2Xl()') ||
-                                initText.includes('injectIsBase()') ||
-                                initText.includes('injectCurrentBreakpoint()') ||
-                                initText.includes('injectViewportDimensions()') ||
-                                initText.includes('injectScrollbarDimensions()') ||
-                                initText.includes('injectObserveBreakpoint()') ||
-                                initText.includes('injectBreakpointIsMatched()');
-                            if (usesSignalInject && !initText.includes('toObservable(')) {
-                                templateMigrationInfo.signalProperties.add(memberName);
-                            }
-                        }
-                    }
-                });
-            }
-        });
-        // Only add to componentTemplateMigrations if there's an external template
-        if (templatePath && templateMigrationInfo.signalProperties.size > 0) {
-            componentTemplateMigrations.set(filePath, templateMigrationInfo);
-        }
-        const updatedSourceFileForInline = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
-        updatedSourceFileForInline.forEachChild((node) => {
-            if (ts.isClassDeclaration(node)) {
-                const decorators = 
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                ts.getDecorators?.(node) ?? node.decorators;
-                decorators?.forEach((decorator) => {
-                    if (ts.isCallExpression(decorator.expression) &&
-                        decorator.expression.arguments.length > 0 &&
-                        ts.isObjectLiteralExpression(decorator.expression.arguments[0])) {
-                        const obj = decorator.expression.arguments[0];
-                        obj.properties.forEach((prop) => {
-                            if (ts.isPropertyAssignment(prop) &&
-                                ts.isIdentifier(prop.name) &&
-                                prop.name.text === 'template' &&
-                                (ts.isNoSubstitutionTemplateLiteral(prop.initializer) || ts.isStringLiteral(prop.initializer))) {
-                                let templateText = prop.initializer.getText();
-                                // Remove the surrounding quotes/backticks
-                                templateText = templateText.slice(1, -1);
-                                // For each signal property, replace usages with ()
-                                for (const propName of templateMigrationInfo.signalProperties) {
-                                    const regex = new RegExp(`\\b${propName}(?!\\s*\\()\\b`, 'g');
-                                    templateText = templateText.replace(regex, `${propName}()`);
-                                }
-                                // Re-wrap with original quotes/backticks
-                                const quote = prop.initializer.getText()[0];
-                                const newInitializer = quote + templateText + quote;
-                                // Replace in the file content
-                                updatedContent =
-                                    updatedContent.slice(0, prop.initializer.getStart(updatedSourceFileForInline)) +
-                                        newInitializer +
-                                        updatedContent.slice(prop.initializer.getEnd());
-                            }
-                        });
-                    }
-                });
+        review.push(...findSyncObservableConsumers(filePath, content, updatedContent));
+        const sourceFileForTemplates = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
+        const originalClasses = collectClasses(sourceFile);
+        const inlineTemplateEdits = [];
+        collectClasses(sourceFileForTemplates).forEach((classNode, index) => {
+            if (originalClasses[index]?.getText(sourceFile) === classNode.getText(sourceFileForTemplates))
+                return;
+            const signalProperties = collectSignalProperties(sourceFileForTemplates, classNode);
+            if (signalProperties.size === 0)
+                return;
+            const template = findComponentTemplate(classNode);
+            if (!template)
+                return;
+            if (template.kind === 'url') {
+                const componentDir = filePath.substring(0, filePath.lastIndexOf('/'));
+                const templatePath = `${componentDir}/${template.path}`.replace(/\/\.\//g, '/').replace(/\/\//g, '/');
+                const existing = externalTemplateMigrations.get(templatePath) ?? new Set();
+                signalProperties.forEach((property) => existing.add(property));
+                externalTemplateMigrations.set(templatePath, existing);
+                return;
             }
+            const initializerText = template.initializer.getText(sourceFileForTemplates);
+            const quote = initializerText[0];
+            inlineTemplateEdits.push({
+                start: template.initializer.getStart(sourceFileForTemplates),
+                end: template.initializer.getEnd(),
+                replacement: quote + migrateTemplateText(initializerText.slice(1, -1), signalProperties) + quote,
+            });
         });
-        // Write the updated content if changes were made
+        inlineTemplateEdits.sort((a, b) => b.start - a.start);
+        for (const edit of inlineTemplateEdits) {
+            updatedContent = updatedContent.slice(0, edit.start) + edit.replacement + updatedContent.slice(edit.end);
+        }
         if (updatedContent !== content) {
             tree.write(filePath, updatedContent);
             filesModified++;
         }
     }
-    // Migrate templates
-    for (const [tsFilePath, migrationInfo] of componentTemplateMigrations) {
-        const sourceFile = ts.createSourceFile(tsFilePath, tree.read(tsFilePath, 'utf-8'), ts.ScriptTarget.Latest, true);
-        const templatePath = findTemplateForComponent(tree, tsFilePath, sourceFile);
-        if (templatePath && tree.exists(templatePath)) {
-            logger.log(`Processing template: ${templatePath}`);
-            const wasModified = migrateTemplateFile(tree, templatePath, migrationInfo);
-            if (wasModified) {
-                templatesModified++;
-            }
+    for (const [templatePath, signalProperties] of externalTemplateMigrations) {
+        if (tree.exists(templatePath) && migrateTemplateFile(tree, templatePath, { signalProperties })) {
+            templatesModified++;
         }
     }
-    // Log results
-    if (filesModified > 0 || templatesModified > 0) {
-        logger.log(`\n✅ Successfully migrated ViewportService in ${filesModified} TypeScript file(s) and ${templatesModified} template(s)\n`);
-    }
-    else if (viewportServiceUsed) {
-        logger.log('\nℹ️  ViewportService detected but no migrations needed\n');
-    }
-    else {
-        logger.log('\nℹ️  No ViewportService usage found\n');
-    }
+    return { filesChanged: filesModified + templatesModified, review };
 }
-function detectCssVariableUsage(tree, styleFiles) {
-    let hasViewportVariables = false;
-    let hasScrollbarVariables = false;
-    // Check both style files AND TypeScript files (for inline styles)
-    const allFiles = [...styleFiles];
-    // Also check all TypeScript files for inline styles
-    function findTsFiles(dir) {
-        const children = tree.children(dir);
-        for (const child of children) {
-            const path = dir === '.' ? child : `${dir}/${child}`;
-            if (tree.isFile(path) && path.endsWith('.ts')) {
-                allFiles.push(path);
-            }
-            else if (!tree.isFile(path)) {
-                findTsFiles(path);
-            }
+const SIGNAL_INJECT_CALLS = [
+    'injectIsXs()',
+    'injectIsSm()',
+    'injectIsMd()',
+    'injectIsLg()',
+    'injectIsXl()',
+    'injectIs2Xl()',
+    'injectIsBase()',
+    'injectCurrentBreakpoint()',
+    'injectViewportDimensions()',
+    'injectScrollbarDimensions()',
+    'injectObserveBreakpoint()',
+    'injectBreakpointIsMatched()',
+];
+function collectSignalProperties(sourceFile, classNode) {
+    const signalProperties = new Set();
+    for (const member of classNode.members) {
+        if (!ts.isPropertyDeclaration(member) || !ts.isIdentifier(member.name) || !member.initializer)
+            continue;
+        if (member.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.PrivateKeyword))
+            continue;
+        const initText = member.initializer.getText(sourceFile);
+        if (SIGNAL_INJECT_CALLS.some((call) => initText.includes(call)) && !initText.includes('toObservable(')) {
+            signalProperties.add(member.name.text);
         }
     }
-    findTsFiles('.');
-    for (const filePath of allFiles) {
-        const content = tree.read(filePath, 'utf-8');
-        if (!content)
+    return signalProperties;
+}
+function findComponentTemplate(classNode) {
+    for (const decorator of ts.getDecorators(classNode) ?? []) {
+        const metadata = ts.isCallExpression(decorator.expression) ? decorator.expression.arguments[0] : undefined;
+        if (!metadata || !ts.isObjectLiteralExpression(metadata))
             continue;
-        if (content.includes('--et-vw') || content.includes('--et-vh')) {
-            hasViewportVariables = true;
-        }
-        if (content.includes('--et-sw') || content.includes('--et-sh')) {
-            hasScrollbarVariables = true;
-        }
-        if (hasViewportVariables && hasScrollbarVariables) {
-            break; // Found both, no need to continue
+        for (const prop of metadata.properties) {
+            if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+                continue;
+            if (!ts.isNoSubstitutionTemplateLiteral(prop.initializer) && !ts.isStringLiteral(prop.initializer))
+                continue;
+            if (prop.name.text === 'template')
+                return { kind: 'inline', initializer: prop.initializer };
+            if (prop.name.text === 'templateUrl')
+                return { kind: 'url', path: prop.initializer.text };
         }
     }
-    return { hasViewportVariables, hasScrollbarVariables };
+    return null;
 }
+const migrateTemplateExpression = (expression, signalProperties) => {
+    let migrated = expression;
+    for (const propName of signalProperties) {
+        const regex = new RegExp(`\\b${escapeRegExp(propName)}(?!\\s*\\()\\b`, 'g');
+        migrated = migrated.replace(regex, `${propName}()`);
+    }
+    return migrated;
+};
+const migrateTemplateText = (template, signalProperties) => template
+    .replace(/{{([\s\S]*?)}}/g, (_, expression) => `{{${migrateTemplateExpression(expression, signalProperties)}}}`)
+    .replace(/((?:\[[^\]]+\]|\([^)]+\)|\*[\w.-]+)\s*=\s*)(["'])([\s\S]*?)\2/g, (_, prefix, quote, expression) => `${prefix}${quote}${migrateTemplateExpression(expression, signalProperties)}${quote}`)
+    .replace(/@(if|for|switch|case|defer)\s*\(([^\n{}]*)\)/g, (_, block, expression) => `@${block} (${migrateTemplateExpression(expression, signalProperties)})`);
 function migrateTemplateFile(tree, htmlFilePath, migrationInfo) {
     const content = tree.read(htmlFilePath, 'utf-8');
     if (!content)
         return false;
-    let updatedContent = content;
-    let hasChanges = false;
-    // For each signal property, replace usages with () calls
-    for (const propName of migrationInfo.signalProperties) {
-        // Match property usage in various Angular contexts:
-        // 1. Interpolation: {{ propName }}
-        // 2. Property binding: [prop]="propName"
-        // 3. Event binding: (event)="propName === value"
-        // 4. Structural directives: *ngIf="propName"
-        // But NOT if already called: propName()
-        // Create a regex that matches the property but not if followed by (
-        const regex = new RegExp(`\\b${escapeRegExp(propName)}(?!\\s*\\()\\b`, 'g');
-        const newContent = updatedContent.replace(regex, `${propName}()`);
-        if (newContent !== updatedContent) {
-            updatedContent = newContent;
-            hasChanges = true;
-        }
-    }
+    const updatedContent = migrateTemplateText(content, migrationInfo.signalProperties);
+    const hasChanges = updatedContent !== content;
     if (hasChanges) {
         tree.write(htmlFilePath, updatedContent);
     }
     return hasChanges;
 }
-function findTemplateForComponent(tree, tsFilePath, sourceFile) {
-    let templatePath = null;
-    function visit(node) {
-        if (templatePath)
-            return;
-        // Look for @Component decorator
-        if (ts.isDecorator(node)) {
-            const expression = node.expression;
-            if (ts.isCallExpression(expression)) {
-                const args = expression.arguments;
-                if (args.length > 0 && ts.isObjectLiteralExpression(args[0])) {
-                    const properties = args[0].properties;
-                    for (const prop of properties) {
-                        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === 'templateUrl') {
-                            if (ts.isStringLiteral(prop.initializer)) {
-                                const templateRelativePath = prop.initializer.text;
-                                // Resolve the template path relative to the component file
-                                const componentDir = tsFilePath.substring(0, tsFilePath.lastIndexOf('/'));
-                                templatePath = `${componentDir}/${templateRelativePath}`;
-                                // Normalize the path
-                                templatePath = templatePath.replace(/\/\.\//g, '/').replace(/\/\//g, '/');
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        ts.forEachChild(node, visit);
-    }
-    visit(sourceFile);
-    return templatePath;
-}
 function getViewportServicePackage(sourceFile) {
     let packageName = null;
     sourceFile.forEachChild((node) => {
         if (ts.isImportDeclaration(node) && node.importClause?.namedBindings) {
             if (ts.isNamedImports(node.importClause.namedBindings)) {
-                const hasViewportService = node.importClause.namedBindings.elements.some((el) => el.name.text === 'ViewportService');
+                const hasViewportService = node.importClause.namedBindings.elements.some((el) => (el.propertyName?.text ?? el.name.text) === 'ViewportService');
                 if (hasViewportService && ts.isStringLiteral(node.moduleSpecifier)) {
                     packageName = node.moduleSpecifier.text;
                 }
@@ -359,7 +230,7 @@ function getPropertyMaps(packageName) {
         isLg: isEthleteCore ? 'injectIsLg' : 'injectIsXl',
         isXl: isEthleteCore ? 'injectIsXl' : 'injectIs2Xl',
         is2Xl: 'injectIs2Xl',
-        isBase: isEthleteCore ? 'injectIsBase' : 'injectIsLg',
+        isBase: 'injectIsLg',
         viewportSize: 'injectViewportDimensions',
         scrollbarSize: 'injectScrollbarDimensions',
         currentViewport: 'injectCurrentBreakpoint',
@@ -500,7 +371,7 @@ function analyzeClassMigration(sourceFile, classNode, viewportServiceVar) {
     });
     // Group property initializer usages by their ViewportService usage pattern
     const propertyInitializerUsages = new Map();
-    for (const [usageText, { propertyName, usage, propertyDecl }] of usagesInPropertyInitializers) {
+    for (const [, { propertyName, usage, propertyDecl }] of usagesInPropertyInitializers) {
         let injectFn;
         let args;
         let type = 'signal';
@@ -568,7 +439,7 @@ function analyzeClassMigration(sourceFile, classNode, viewportServiceVar) {
             });
         if (isUsedOutsideInitializers && type === 'observable') {
             // Create a shared member for all properties that use this observable
-            const baseName = args ? generateNameFromArgs(usageKey, args, type) : usageKey;
+            const baseName = args ? generateNameFromArgs(args, type) : usageKey;
             const memberName = findAvailableMemberName(baseName, context.existingMembers);
             const memberInfo = {
                 name: memberName,
@@ -599,7 +470,7 @@ function analyzeClassMigration(sourceFile, classNode, viewportServiceVar) {
                 // OR if the property is used elsewhere in the class
                 const propertyName = ts.isIdentifier(propertyDecl.name) ? propertyDecl.name.text : '';
                 const isObservableProperty = propertyName.endsWith('$');
-                const isPropertyUsedElsewhere = checkIfPropertyIsUsedElsewhere(sourceFile, classNode, propertyName, propertyDecl);
+                const isPropertyUsedElsewhere = checkIfPropertyIsUsedElsewhere(classNode, propertyName, propertyDecl);
                 // Wrap with toObservable if:
                 // 1. It's an observable type AND
                 // 2. (Property name ends with $ OR property is used elsewhere)
@@ -718,7 +589,7 @@ function analyzeClassMigration(sourceFile, classNode, viewportServiceVar) {
         else {
             let baseName;
             if (usage.args) {
-                baseName = generateNameFromArgs(originalProperty, usage.args, usage.type);
+                baseName = generateNameFromArgs(usage.args, usage.type);
             }
             else {
                 baseName = usage.type === 'observable' ? originalProperty : originalProperty.replace(/\$$/, '');
@@ -843,7 +714,7 @@ function addMembersToClass(sourceFile, content, classNode, membersToAdd, viewpor
             const classText = classNode.getText(sourceFile);
             const openBraceIndex = classText.indexOf('{');
             if (openBraceIndex === -1) {
-                console.warn('Could not find class body opening brace');
+                logger.warn('Could not find class body opening brace');
                 return content;
             }
             const classStart = classNode.getStart(sourceFile);
@@ -889,70 +760,57 @@ function addMembersToClass(sourceFile, content, classNode, membersToAdd, viewpor
     }
     return content.slice(0, finalInsertPosition) + prefix + newMembers + suffix + content.slice(finalInsertPosition);
 }
-function removeViewportServiceInjection(sourceFile, content, viewportServiceVars, filePath) {
+function removeViewportServiceInjection(sourceFile, content, serviceName, filePath) {
     let updatedContent = content;
     const modifications = [];
-    // Collect all modifications first (in reverse order by position)
-    sourceFile.forEachChild((node) => {
-        if (ts.isClassDeclaration(node)) {
-            // Collect property removals
-            node.members.forEach((member) => {
-                if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name)) {
-                    const memberName = member.name.text;
-                    if (viewportServiceVars.includes(memberName)) {
-                        const memberStart = member.getStart(sourceFile, true);
-                        const memberEnd = member.getEnd();
-                        // Find the line boundaries
-                        let lineStart = memberStart;
-                        while (lineStart > 0 && content[lineStart - 1] !== '\n') {
-                            lineStart--;
-                        }
-                        let lineEnd = memberEnd;
-                        while (lineEnd < content.length && content[lineEnd] !== '\n') {
-                            lineEnd++;
-                        }
-                        if (content[lineEnd] === '\n') {
-                            lineEnd++;
-                        }
-                        modifications.push({ start: lineStart, end: lineEnd, replacement: '' });
+    collectClasses(sourceFile).forEach((node) => {
+        node.members.forEach((member) => {
+            if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name)) {
+                if (isServiceProperty(member, serviceName)) {
+                    const memberStart = member.getStart(sourceFile, true);
+                    const memberEnd = member.getEnd();
+                    // Find the line boundaries
+                    let lineStart = memberStart;
+                    while (lineStart > 0 && content[lineStart - 1] !== '\n') {
+                        lineStart--;
                     }
-                }
-            });
-            // Collect constructor parameter modifications
-            node.members.forEach((member) => {
-                if (ts.isConstructorDeclaration(member) && member.parameters.length > 0) {
-                    const newParams = [];
-                    member.parameters.forEach((param) => {
-                        if (ts.isIdentifier(param.name)) {
-                            const paramName = param.name.text;
-                            // Skip ViewportService parameters
-                            if (viewportServiceVars.includes(paramName)) {
-                                return;
-                            }
-                        }
-                        // Keep this parameter
-                        newParams.push(param.getText(sourceFile));
-                    });
-                    // Find parameter list boundaries
-                    const constructorText = member.getText(sourceFile);
-                    const openParenIndex = constructorText.indexOf('(');
-                    const closeParenIndex = findMatchingParen(constructorText, openParenIndex);
-                    if (openParenIndex === -1 || closeParenIndex === -1) {
-                        console.warn(`Could not find constructor parameters in ${filePath}`);
-                        return;
+                    let lineEnd = memberEnd;
+                    while (lineEnd < content.length && content[lineEnd] !== '\n') {
+                        lineEnd++;
                     }
-                    const constructorStart = member.getStart(sourceFile);
-                    const paramListStart = constructorStart + openParenIndex + 1;
-                    const paramListEnd = constructorStart + closeParenIndex;
-                    const newParamsText = newParams.join(', ');
-                    modifications.push({
-                        start: paramListStart,
-                        end: paramListEnd,
-                        replacement: newParamsText,
-                    });
+                    if (content[lineEnd] === '\n') {
+                        lineEnd++;
+                    }
+                    modifications.push({ start: lineStart, end: lineEnd, replacement: '' });
                 }
-            });
-        }
+            }
+        });
+        // Collect constructor parameter modifications
+        node.members.forEach((member) => {
+            if (ts.isConstructorDeclaration(member) &&
+                member.parameters.some((param) => isServiceParameter(param, serviceName))) {
+                const newParams = member.parameters
+                    .filter((param) => !isServiceParameter(param, serviceName))
+                    .map((param) => param.getText(sourceFile));
+                // Find parameter list boundaries
+                const constructorText = member.getText(sourceFile);
+                const openParenIndex = constructorText.indexOf('(');
+                const closeParenIndex = findMatchingParen(constructorText, openParenIndex);
+                if (openParenIndex === -1 || closeParenIndex === -1) {
+                    logger.warn(`Could not find constructor parameters in ${filePath}`);
+                    return;
+                }
+                const constructorStart = member.getStart(sourceFile);
+                const paramListStart = constructorStart + openParenIndex + 1;
+                const paramListEnd = constructorStart + closeParenIndex;
+                const newParamsText = newParams.join(', ');
+                modifications.push({
+                    start: paramListStart,
+                    end: paramListEnd,
+                    replacement: newParamsText,
+                });
+            }
+        });
     });
     // Sort modifications by start position (descending) to apply from end to start
     modifications.sort((a, b) => b.start - a.start);
@@ -976,7 +834,7 @@ function findMatchingParen(text, openIndex) {
     }
     return depth === 0 ? i - 1 : -1;
 }
-function generateNameFromArgs(methodName, args, type) {
+function generateNameFromArgs(args, type) {
     // Parse the arguments to generate a meaningful name
     // e.g., { min: 'lg' } => isMinLg or isMinLg$
     // e.g., { max: 'sm' } => isMaxSm or isMaxSm$
@@ -1061,39 +919,10 @@ function createReplacementsForMember(sourceFile, classNode, viewportServiceVar,
         visitNode(member);
     });
 }
-function findClassForViewportService(sourceFile, viewportServiceVar) {
-    let classNode;
-    function visit(node) {
-        if (classNode)
-            return;
-        if (ts.isClassDeclaration(node)) {
-            // Check if this class has the viewportService member
-            const hasMember = node.members.some((member) => {
-                if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name)) {
-                    return member.name.text === viewportServiceVar;
-                }
-                if (ts.isParameter(member) && ts.isIdentifier(member.name)) {
-                    return member.name.text === viewportServiceVar;
-                }
-                // Check constructor parameters
-                if (ts.isConstructorDeclaration(member)) {
-                    return member.parameters.some((param) => ts.isIdentifier(param.name) && param.name.text === viewportServiceVar);
-                }
-                return false;
-            });
-            if (hasMember) {
-                classNode = node;
-            }
-        }
-        ts.forEachChild(node, visit);
-    }
-    visit(sourceFile);
-    return classNode;
-}
 function findAvailableMemberName(baseName, existingMembers) {
     // baseName already has $ suffix for observables at this point
     // Try variations: name, _name, #name
-    const candidates = [baseName, `_${baseName}`, `#${baseName}`];
+    const candidates = [baseName, `_${baseName}`];
     for (const candidate of candidates) {
         if (!existingMembers.has(candidate)) {
             return candidate;
@@ -1106,7 +935,7 @@ function findAvailableMemberName(baseName, existingMembers) {
     }
     return `${baseName}${counter}`;
 }
-function migrateMonitorViewport(sourceFile, content, viewportServiceVars, cssVariablesUsed) {
+function migrateMonitorViewport(sourceFile, content, viewportServiceVars) {
     let updatedContent = content;
     const imports = [];
     const monitorViewportCalls = [];
@@ -1161,29 +990,8 @@ function migrateMonitorViewport(sourceFile, content, viewportServiceVars, cssVar
         return { content, imports };
     }
     // Determine what to add to constructor
-    const constructorStatements = [];
-    if (cssVariablesUsed.hasViewportVariables) {
-        constructorStatements.push('writeViewportSizeToCssVariables();');
-        imports.push('writeViewportSizeToCssVariables');
-    }
-    if (cssVariablesUsed.hasScrollbarVariables) {
-        constructorStatements.push('writeScrollbarSizeToCssVariables();');
-        imports.push('writeScrollbarSizeToCssVariables');
-    }
-    if (constructorStatements.length === 0) {
-        // Just remove monitorViewport calls
-        const modifications = monitorViewportCalls.map((call) => ({
-            start: call.start,
-            end: call.end,
-            replacement: '',
-        }));
-        // Apply modifications from end to start
-        modifications.sort((a, b) => b.start - a.start);
-        for (const mod of modifications) {
-            updatedContent = updatedContent.slice(0, mod.start) + mod.replacement + updatedContent.slice(mod.end);
-        }
-        return { content: updatedContent, imports };
-    }
+    const constructorStatements = ['writeViewportSizeToCssVariables();', 'writeScrollbarSizeToCssVariables();'];
+    imports.push('writeViewportSizeToCssVariables', 'writeScrollbarSizeToCssVariables');
     // Group calls by class
     const callsByClass = new Map();
     for (const call of monitorViewportCalls) {
@@ -1232,7 +1040,7 @@ function migrateMonitorViewport(sourceFile, content, viewportServiceVars, cssVar
             const classText = classNode.getText(sourceFile);
             const openBraceIndex = classText.indexOf('{');
             if (openBraceIndex === -1) {
-                console.warn('Could not find class body opening brace');
+                logger.warn('Could not find class body opening brace');
                 continue;
             }
             const insertPosition = classStart + openBraceIndex + 1;
@@ -1278,13 +1086,15 @@ function addImportsToPackage(sourceFile, content, neededImports, packageName) {
         statement.moduleSpecifier.text === packageName);
     const importsToAdd = Array.from(neededImports).sort();
     if (existingImport?.importClause?.namedBindings && ts.isNamedImports(existingImport.importClause.namedBindings)) {
-        const existingImportNames = existingImport.importClause.namedBindings.elements.map((el) => el.name.text);
-        const newImports = importsToAdd.filter((imp) => !existingImportNames.includes(imp));
+        const existingElements = existingImport.importClause.namedBindings.elements;
+        const existingImportedNames = existingElements.map((el) => el.propertyName?.text ?? el.name.text);
+        const existingImportNames = existingElements.map((el) => el.getText(sourceFile));
+        const newImports = importsToAdd.filter((imp) => !existingImportedNames.includes(imp));
         if (newImports.length > 0) {
             const allImports = [...existingImportNames, ...newImports].sort();
             const importText = existingImport.getText(sourceFile);
             const newImportText = `import { ${allImports.join(', ')} } from '${packageName}';`;
-            return content.replace(importText, newImportText);
+            return content.replace(importText, () => newImportText);
         }
     }
     else if (!existingImport) {
@@ -1295,87 +1105,7 @@ function addImportsToPackage(sourceFile, content, neededImports, packageName) {
     }
     return content;
 }
-function checkIfViewportServiceStillUsed(sourceFile, viewportServiceVars) {
-    let stillUsed = false;
-    function visit(node) {
-        if (stillUsed || !ts.isPropertyAccessExpression(node)) {
-            if (!stillUsed)
-                ts.forEachChild(node, visit);
-            return;
-        }
-        const expression = node.expression;
-        const isUsed = (ts.isPropertyAccessExpression(expression) && viewportServiceVars.includes(expression.name.text)) ||
-            (ts.isIdentifier(expression) && viewportServiceVars.includes(expression.text));
-        if (isUsed) {
-            stillUsed = true;
-        }
-        else {
-            ts.forEachChild(node, visit);
-        }
-    }
-    visit(sourceFile);
-    return stillUsed;
-}
-function removeViewportServiceImport(sourceFile, content) {
-    let updatedContent = content;
-    sourceFile.forEachChild((node) => {
-        if (ts.isImportDeclaration(node)) {
-            const moduleSpecifier = node.moduleSpecifier;
-            if (ts.isStringLiteral(moduleSpecifier)) {
-                const importPath = moduleSpecifier.text;
-                // Check if this import contains ViewportService from any package
-                // (e.g., '@ethlete/core' or '@fifa-gg/uikit/core')
-                if (!node.importClause?.namedBindings)
-                    return;
-                if (ts.isNamedImports(node.importClause.namedBindings)) {
-                    const imports = node.importClause.namedBindings.elements;
-                    const viewportServiceImport = imports.find((imp) => ts.isImportSpecifier(imp) && imp.name.text === 'ViewportService');
-                    if (!viewportServiceImport)
-                        return;
-                    // If ViewportService is the only import, remove the entire import statement
-                    if (imports.length === 1) {
-                        const importText = node.getText(sourceFile);
-                        const importStart = node.getStart(sourceFile);
-                        const importEnd = node.getEnd();
-                        // Find the end of the line (including newline)
-                        let lineEnd = importEnd;
-                        while (lineEnd < content.length && content[lineEnd] !== '\n') {
-                            lineEnd++;
-                        }
-                        if (content[lineEnd] === '\n') {
-                            lineEnd++;
-                        }
-                        updatedContent = content.slice(0, importStart) + content.slice(lineEnd);
-                    }
-                    else {
-                        // Remove only ViewportService from the named imports
-                        const viewportServiceText = viewportServiceImport.getText(sourceFile);
-                        const namedImportsText = node.importClause.namedBindings.getText(sourceFile);
-                        // Handle different formatting cases
-                        const patterns = [
-                            new RegExp(`ViewportService,\\s*`, 'g'), // ViewportService at start/middle
-                            new RegExp(`,\\s*ViewportService`, 'g'), // ViewportService at end
-                            new RegExp(`\\s*ViewportService\\s*`, 'g'), // ViewportService alone
-                        ];
-                        let newNamedImports = namedImportsText;
-                        for (const pattern of patterns) {
-                            const temp = newNamedImports.replace(pattern, '');
-                            if (temp !== newNamedImports) {
-                                newNamedImports = temp;
-                                break;
-                            }
-                        }
-                        // Clean up any double commas or spaces
-                        newNamedImports = newNamedImports.replace(/,\s*,/g, ',').replace(/{\s*,/g, '{').replace(/,\s*}/g, '}');
-                        updatedContent = updatedContent.replace(namedImportsText, newNamedImports);
-                    }
-                }
-            }
-        }
-    });
-    return updatedContent;
-}
-function findViewportServiceVariables(sourceFile) {
+function findViewportServiceVariables(sourceFile, serviceName) {
     const variables = [];
     function visit(node) {
         // Check for inject(ViewportService) pattern
@@ -1384,7 +1114,7 @@ function findViewportServiceVariables(sourceFile) {
             node.expression.text === 'inject' &&
             node.arguments.length > 0) {
             const arg = node.arguments[0];
-            if (ts.isIdentifier(arg) && arg.text === 'ViewportService') {
+            if (ts.isIdentifier(arg) && arg.text === serviceName) {
                 // Find the variable name
                 let parent = node.parent;
                 while (parent) {
@@ -1404,7 +1134,7 @@ function findViewportServiceVariables(sourceFile) {
         if (ts.isParameter(node)) {
             const typeNode = node.type;
             if (typeNode && ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
-                if (typeNode.typeName.text === 'ViewportService' && node.name && ts.isIdentifier(node.name)) {
+                if (typeNode.typeName.text === serviceName && node.name && ts.isIdentifier(node.name)) {
                     variables.push(node.name.text);
                 }
             }
@@ -1414,9 +1144,9 @@ function findViewportServiceVariables(sourceFile) {
     visit(sourceFile);
     return variables;
 }
-function handleInlineInjectPatterns(sourceFile, content) {
+function handleInlineInjectPatterns(sourceFile, content, serviceName) {
     const importsNeeded = new Set();
-    let updatedContent = content;
+    const edits = [];
     // Get the ViewportService package to determine mapping
     const packageName = getViewportServicePackage(sourceFile);
     const { signalPropertyMap, observablePropertyMap } = getPropertyMaps(packageName);
@@ -1450,12 +1180,11 @@ function handleInlineInjectPatterns(sourceFile, content) {
                     arg.expression.expression.text === 'inject' &&
                     arg.expression.arguments.length > 0) {
                     const injectArg = arg.expression.arguments[0];
-                    if (ts.isIdentifier(injectArg) && injectArg.text === 'ViewportService') {
+                    if (ts.isIdentifier(injectArg) && injectArg.text === serviceName) {
                         const injectFn = signalPropertyMap[propertyName] || observablePropertyMap[propertyName];
                         if (injectFn) {
-                            const oldText = node.getText(sourceFile);
                             const newText = `${injectFn}()`;
-                            updatedContent = updatedContent.replace(oldText, newText);
+                            edits.push({ start: node.getStart(sourceFile), end: node.getEnd(), text: newText });
                             importsNeeded.add(injectFn);
                             processedNodes.add(arg);
                         }
@@ -1472,13 +1201,12 @@ function handleInlineInjectPatterns(sourceFile, content) {
                     arg.expression.expression.expression.text === 'inject' &&
                     arg.expression.expression.arguments.length > 0) {
                     const injectArg = arg.expression.expression.arguments[0];
-                    if (ts.isIdentifier(injectArg) && injectArg.text === 'ViewportService') {
-                        const oldText = node.getText(sourceFile);
+                    if (ts.isIdentifier(injectArg) && injectArg.text === serviceName) {
                         // Extract arguments from the method call
                         const args = arg.arguments.map((a) => a.getText(sourceFile)).join(', ');
                         // Since it's wrapped in toSignal and our inject functions return signals, remove toSignal
                         const newText = `${methodInfo.injectFn}(${args})`;
-                        updatedContent = updatedContent.replace(oldText, newText);
+                        edits.push({ start: node.getStart(sourceFile), end: node.getEnd(), text: newText });
                         importsNeeded.add(methodInfo.injectFn);
                         processedNodes.add(arg);
                     }
@@ -1499,12 +1227,11 @@ function handleInlineInjectPatterns(sourceFile, content) {
                 node.expression.expression.expression.text === 'inject' &&
                 node.expression.expression.arguments.length > 0) {
                 const injectArg = node.expression.expression.arguments[0];
-                if (ts.isIdentifier(injectArg) && injectArg.text === 'ViewportService') {
+                if (ts.isIdentifier(injectArg) && injectArg.text === serviceName) {
                     if (isInsideToSignal(node)) {
                         ts.forEachChild(node, visitNode);
                         return;
                     }
-                    const oldText = node.getText(sourceFile);
                     const args = node.arguments.map((arg) => arg.getText(sourceFile)).join(', ');
                     // Only wrap with toObservable if the assigned variable/property ends with $
                     let needsToObservable = false;
@@ -1518,7 +1245,7 @@ function handleInlineInjectPatterns(sourceFile, content) {
                         newText = `toObservable(${newText})`;
                         importsNeeded.add('toObservable');
                     }
-                    updatedContent = updatedContent.replace(oldText, newText);
+                    edits.push({ start: node.getStart(sourceFile), end: node.getEnd(), text: newText });
                     importsNeeded.add(methodInfo.injectFn);
                 }
             }
@@ -1535,14 +1262,13 @@ function handleInlineInjectPatterns(sourceFile, content) {
                 node.expression.expression.text === 'inject' &&
                 node.expression.arguments.length > 0) {
                 const injectArg = node.expression.arguments[0];
-                if (ts.isIdentifier(injectArg) && injectArg.text === 'ViewportService') {
+                if (ts.isIdentifier(injectArg) && injectArg.text === serviceName) {
                     const injectFn = signalPropertyMap[propertyName] || observablePropertyMap[propertyName];
                     if (injectFn) {
                         if (isInsideToSignal(node)) {
                             ts.forEachChild(node, visitNode);
                             return;
                         }
-                        const oldText = node.getText(sourceFile);
                         // Check if this is an observable property (ends with $)
                         const isObservable = !!observablePropertyMap[propertyName];
                         let newText = `${injectFn}()`;
@@ -1550,7 +1276,7 @@ function handleInlineInjectPatterns(sourceFile, content) {
                             newText = `toObservable(${newText})`;
                             importsNeeded.add('toObservable');
                         }
-                        updatedContent = updatedContent.replace(oldText, newText);
+                        edits.push({ start: node.getStart(sourceFile), end: node.getEnd(), text: newText });
                         importsNeeded.add(injectFn);
                     }
                 }
@@ -1559,7 +1285,7 @@ function handleInlineInjectPatterns(sourceFile, content) {
         ts.forEachChild(node, visitNode);
     }
     sourceFile.forEachChild(visitNode);
-    return { content: updatedContent, importsNeeded };
+    return { content: applyInlineEdits(content, edits), importsNeeded };
 }
 function removeUnusedImports(sourceFile, content) {
     const importsToCheck = [
@@ -1569,14 +1295,14 @@ function removeUnusedImports(sourceFile, content) {
     let updatedContent = content;
     for (const importToCheck of importsToCheck) {
         // Check if the import specifier is used anywhere in the code
-        const isUsed = checkIfImportIsUsed(sourceFile, content, importToCheck.specifier);
+        const isUsed = checkIfImportIsUsed(sourceFile, importToCheck.specifier);
         if (!isUsed) {
             updatedContent = removeImportSpecifier(sourceFile, updatedContent, importToCheck.specifier, importToCheck.package);
         }
     }
     return updatedContent;
 }
-function checkIfImportIsUsed(sourceFile, content, specifier) {
+function checkIfImportIsUsed(sourceFile, specifier) {
     let isUsed = false;
     function visit(node) {
         if (isUsed)
@@ -1641,7 +1367,7 @@ function removeImportSpecifier(sourceFile, content, specifier, packageName) {
     });
     return updatedContent;
 }
-function checkIfPropertyIsUsedElsewhere(sourceFile, classNode, propertyName, propertyDecl) {
+function checkIfPropertyIsUsedElsewhere(classNode, propertyName, propertyDecl) {
     let isUsed = false;
     function visit(node) {
         if (isUsed)
@@ -1675,4 +1401,13 @@ function checkIfPropertyIsUsedElsewhere(sourceFile, classNode, propertyName, pro
     });
     return isUsed;
 }
-//# sourceMappingURL=viewport-service.js.map
+function applyInlineEdits(content, edits) {
+    const accepted = [];
+    for (const edit of [...edits].sort((a, b) => a.start - b.start || b.end - a.end)) {
+        const last = accepted.at(-1);
+        if (last && edit.start < last.end)
+            continue;
+        accepted.push(edit);
+    }
+    return accepted.reduceRight((result, edit) => result.slice(0, edit.start) + edit.text + result.slice(edit.end), content);
+}