@pi-r/android 0.11.3 → 0.12.1

package/extensions/gradle/dependencies/index.js

@@ -1,17 +1,20 @@
 "use strict";
-const path = require("node:path");
-const fs = require("node:fs");
-const Document = require("@e-mc/document");
-const types_1 = require("@e-mc/types");
-const util_1 = require("@e-mc/document/util");
-const REGEXP_SEMVER = /^((\s*,\s*)?[([\]]((\s*,\s*)?\d+\.\d+(\s*,\s*)?)+[)\][])+$/;
+
+const path = require('node:path');
+const fs = require('node:fs');
+const Document = require('@e-mc/document');
+const { escapePattern, isArray, isString } = require('@e-mc/types');
+const { getIndent, getNewline, spliceString, trimQuote, wrapQuote } = require('@e-mc/document/util');
+const REGEXP_SEMVER = /^((\s*,\s*)?[([\]]((\s*,\s*)?\d+\.\d+(\s*,\s*)?)+[)[\]])+$/;
 const REGEXP_DEPENDENCIES = /dependencies\s+\{((?:{[^{]*{|{[^}]*}|}[^}]*}|\\}*?|[^{}+])+)\}/;
-const REGEXP_DEPENDENCY = /([ \t]*)([A-Za-z_$][\w$]*)(?:\s*\(?\s*(?:module\(?\s*)?["']([^"']+)["']\s*\)?|\s+((?:\s*(?:group|name|version)\s*:\s*(?:"(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')\s*,?){3}))?/gd;
-const REGEXP_DEPENDENCY_KOTLIN = /([ \t]*)([A-Za-z_$][\w$]*)\((?:\s*(?:(?:module\(\s*)?"([^"]+)"|((?:\s*(?:group|name|version)\s*=\s*"(?:[^"]|(?<=\\)")+"\s*,?){3}))\s*\))?/gd;
-const REGEXP_LIBRARY = /([ \t]*)implementation\s+(?:(project|files)\s*\(\s*("(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')\s*\)|(fileTree)\s*\(\s*((?:\s*(?:dir|include)\s*:\s*(?:"(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+'|\[[^\]]+\])\s*,?){2})\s*\))[ \t\r]*\n/gd;
-const REGEXP_LIBRARY_KOTLIN = /([ \t]*)implementation\(\s*(?:(project|files)\(\s*"(.+)"\s*\)|(fileTree)\(\s*mapOf\(((?:\s*"(?:dir|include)"\s+to\s+(?:"(?:[^"]|(?<=\\)")+"|listOf\([^)]+\))\s*,?){2})\)\s*\))\s*\)[ \t\r]*\n/gd;
-const REGEXP_VERSIONS = /([^\s]+)\s*=\s*(?:"([^"]+)"|'([^']+)'|(\{(?:\s*(?:require|strictly|prefer|reject(?:All)?)\s*=\s*(?:"[^"]+"|'[^']+')\s*,?)+\s*\}))/g;
-const REGEXP_VERSIONS_LIB = /([^\s]+)\s*=\s*(?:\{\s*(group|name|module|version(?:\.ref)?)\s*=\s*(?:"([^"]+)"|'([^']+)'|(\{[^}]+\}))\s*,\s*(group|name|module|version(?:\.ref)?)\s*=\s*(?:"([^"]+)"|'([^']+)'|(\{[^}]+\}))(?:\s*,\s*(group|name|module|version(?:\.ref)?)\s*=\s*(?:"([^"]+)"|'([^']+)')|(\{[^}]+\}))?\s*\}|(?:"([^:]+:[^"]+)"|'([^:]+:[^']+)'))/gd;
+const REGEXP_DEPENDENCY = /([ \t]*)([A-Za-z_$][\w$]*)(?:\s*\(?\s*(?:module\(?\s*)?["']([^"']+)["']\s*\)?|\s+((?:\s*(?:group|name|version)\s*:\s*(?:"(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')\s*,?){3}))?/g;
+const REGEXP_DEPENDENCY_KOTLIN = /([ \t]*)([A-Za-z_$][\w$]*)\((?:\s*(?:(?:module\(\s*)?"([^"]+)"|((?:\s*(?:group|name|version)\s*=\s*"(?:[^"]|(?<=\\)")+"\s*,?){3}))\s*\))?/g;
+const REGEXP_LIBRARY = /([ \t]*)implementation\s+(?:(project|files)\(\s*("(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')\s*\)|(fileTree)\(\s*((?:\s*(?:dir|include)\s*:\s*(?:"(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+'|\[[^\]]+\])\s*,?){2})\s*\))[ \t\r]*\n/g;
+const REGEXP_LIBRARY_KOTLIN = /([ \t]*)implementation\(\s*(?:(project|files)\(\s*"(.+)"\s*\)|(fileTree)\(\s*mapOf\(((?:\s*"(?:dir|include)"\s+to\s+(?:"(?:[^"]|(?<=\\)")+"|listOf\([^)]+\))\s*,?){2})\)\s*\))\s*\)[ \t\r]*\n/g;
+const REGEXP_PLATFORM = /([ \t]*)implementation\s+platform\(\s*("(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')\s*\)[ \t\r]*\n/g;
+const REGEXP_PLATFORM_KOTLIN = /([ \t]*)implementation\(\s*platform\(\s*"(.+)"\s*\)\s*\)[ \t\r]*\n/g;
+const REGEXP_VERSIONS = /(\S+)\s*=\s*(?:"([^"]+)"|'([^']+)'|(\{(?:\s*(?:require|strictly|prefer|reject(?:All)?)\s*=\s*(?:"[^"]+"|'[^']+')\s*,?)+\s*\}))/g;
+const REGEXP_VERSIONS_LIB = /(\S+)\s*=\s*(?:\{\s*(group|name|module|version(?:\.ref)?)\s*=\s*(?:"([^"]+)"|'([^']+)'|(\{[^}]+\}))\s*,\s*(group|name|module|version(?:\.ref)?)\s*=\s*(?:"([^"]+)"|'([^']+)'|(\{[^}]+\}))(?:\s*,\s*(group|name|module|version(?:\.ref)?)\s*=\s*(?:"([^"]+)"|'([^']+)')|(\{[^}]+\}))?\s*\}|(?:"([^:]+:[^"]+)"|'([^:]+:[^']+)'))/gd;
 function isUpgrade(version, pending) {
     if (isSemVer(pending)) {
         return true;
@@ -29,7 +32,7 @@ function isUpgrade(version, pending) {
                 return true;
             }
             if (isNaN(b) || b < a) {
-                break;
+                return false;
             }
         }
     }
@@ -90,15 +93,21 @@ function writeMethod(kotlin, named, item, args = '', prefix = 'implementation')
     else {
         dependency = item.slice(0, 3).join(':');
         if (dependency.endsWith(':')) {
-            dependency = dependency.substring(0, dependency.length - 1);
+            dependency = dependency.slice(0, -1);
         }
         dependency = kotlin ? `("${dependency}")` : ` '${dependency}'`;
     }
     return prefix + dependency;
 }
+function valueFor(name, value, kotlin, quote = false) {
+    value = value.toString();
+    const q = quote ? kotlin && !value.includes('"') || value.includes("'") ? '"' : "'" : '';
+    return `${name} ${kotlin ? '= ' : ''}${q + value + q}`;
+}
 const isLatest = (value) => value === '' || value.startsWith('latest.');
 const isSemVer = (value) => isLatest(value) || REGEXP_SEMVER.test(value);
-const writeOutput = (match, source, value) => (0, util_1.spliceString)(source, match.index, match.index + match[0].length, value);
+const updateOpts = (updateOnly = false) => ({ upgrade: true, updateOnly });
+const writeOutput = (match, source, value) => spliceString(source, match.index, match.index + match[0].length, value);
 const toCamelCase = (value) => value.replace(/-([a-z])/gi, (...capture) => capture[1].toUpperCase());
 function finalize(instance) {
     const { profileable, dependencies, libraries, dataBinding, jvmToolchain, versionName, versionCode, namespace, applicationId, mainParentDir } = instance.config;
@@ -108,8 +117,9 @@ function finalize(instance) {
     let { localUri, source, existing, kotlin = false, language } = instance.findTemplate(path.join(this.baseDirectory, mainParentDir), "build.gradle", { detect: instance.detect(this), languageOf: 'gradle' });
     if (localUri && source && instance.canWrite(localUri, { ownPermissionOnly: true })) {
         const javaVersion = instance.config.javaVersion;
-        let jvmTarget, modified = false;
+        const targetAPI = instance.targetAPI;
         const upgrade = javaVersion > 0;
+        let modified = false;
         const setModified = (output) => {
             if (output !== source) {
                 source = output;
@@ -118,13 +128,13 @@ function finalize(instance) {
         };
         const setDependencies = (match, output) => {
             if (modified || !existing) {
-                setModified((0, util_1.spliceString)(source, match.index, match.index + match[0].length, `dependencies {${output}}`));
+                setModified(spliceString(source, match.index, match.index + match[0].length, `dependencies {${output}}`));
             }
         };
         if (dependencies) {
             const { dependencyScopes, versionCatalog } = instance.config;
-            let mavenData;
-            const hasScope = (value) => (0, types_1.isArray)(dependencyScopes) && dependencyScopes.includes(value) || dependencyScopes === value;
+            let mavenData = null;
+            const hasScope = (value) => isArray(dependencyScopes) && dependencyScopes.includes(value) || dependencyScopes === value;
             const snapshot = dependencyScopes === 1 || hasScope('snapshot');
             const constraints = hasScope('constraints');
             const checkVersion = (item, version, value) => !value && version.startsWith('{') && version.endsWith('}') ? false : snapshot || constraints && !item[2] || (version.length > 0 && !version.startsWith('$') || !kotlin && !!value?.includes("'")) && isUpgrade(version, item[2]);
@@ -146,69 +156,66 @@ function finalize(instance) {
             if (dependencyScopes && (mavenData = getData())) {
                 const supplement = [];
                 for (const item of items) {
-                    const [gId, id] = item;
-                    const target = mavenData[gId]?.find(group => id === group.artifactId);
-                    if (!target) {
-                        continue;
-                    }
-                    if (target.dependencies) {
-                        let found = false;
-                        for (const { groupId, artifactId, version, scope } of target.dependencies) {
-                            if (scope && (dependencyScopes === true || dependencyScopes === 1 || hasScope(scope))) {
-                                let type = -1;
-                                switch (scope) {
-                                    case 'compile':
-                                        type = 0;
-                                        break;
-                                    case 'provided':
-                                        type = 2;
-                                        break;
-                                    case 'runtime':
-                                        type = 4;
-                                        break;
-                                    case 'test':
-                                        type = 5;
-                                        break;
-                                }
-                                if (type !== -1) {
-                                    const current = supplement.find(seg => seg[0] === groupId && seg[1] === artifactId);
-                                    if (current) {
-                                        const t = parseInt(current[3]);
-                                        if (t !== type) {
-                                            const rangeVer = isSemVer(version);
-                                            if (!isSemVer(current[2])) {
-                                                if (rangeVer || type < t) {
+                    const target = mavenData[item[0]]?.find(group => group.artifactId === item[1]);
+                    if (target) {
+                        if (target.dependencies) {
+                            let found = false;
+                            for (const { groupId, artifactId, version, scope } of target.dependencies) {
+                                if (scope && (dependencyScopes === true || dependencyScopes === 1 || hasScope(scope))) {
+                                    let type = -1;
+                                    switch (scope) {
+                                        case 'compile':
+                                            type = 0;
+                                            break;
+                                        case 'provided':
+                                            type = 2;
+                                            break;
+                                        case 'runtime':
+                                            type = 4;
+                                            break;
+                                        case 'test':
+                                            type = 5;
+                                            break;
+                                    }
+                                    if (type !== -1) {
+                                        const current = supplement.find(seg => seg[0] === groupId && seg[1] === artifactId);
+                                        if (current) {
+                                            const t = parseInt(current[3]);
+                                            if (t !== type) {
+                                                const rangeVer = isSemVer(version);
+                                                if (!isSemVer(current[2])) {
+                                                    if (rangeVer || type < t) {
+                                                        current[2] = version;
+                                                        found = true;
+                                                    }
+                                                }
+                                                else if (rangeVer && type < t) {
                                                     current[2] = version;
                                                     found = true;
                                                 }
+                                                current[3] = '0';
                                             }
-                                            else if (rangeVer && type < t) {
+                                            else if (isUpgrade(current[2], version)) {
                                                 current[2] = version;
                                                 found = true;
                                             }
-                                            current[3] = '0';
                                         }
-                                        else if (isUpgrade(current[2], version)) {
-                                            current[2] = version;
+                                        else {
+                                            supplement.push([groupId, artifactId, version, type.toString()]);
                                             found = true;
                                         }
                                     }
-                                    else {
-                                        supplement.push([groupId, artifactId, version, type.toString()]);
-                                        found = true;
-                                    }
                                 }
                             }
+                            if (found && (snapshot || isUpgrade(item[2], target.version))) {
+                                item[2] = target.version;
+                            }
                         }
-                        if (found && (snapshot || isUpgrade(item[2], target.version))) {
-                            item[2] = target.version;
-                        }
+                        break;
                     }
-                    break;
                 }
                 for (const item of supplement) {
-                    const [groupId, artifactId] = item;
-                    const index = items.findIndex(seg => seg[0] === groupId && seg[1] === artifactId);
+                    const index = items.findIndex(seg => seg[0] === item[0] && seg[1] === item[1]);
                     if (index === -1) {
                         items.push(item);
                     }
@@ -231,23 +238,33 @@ function finalize(instance) {
                 }
                 return a[1] < b[1] ? -1 : 1;
             });
-            if (!kotlin && items.some(seg => seg[1].endsWith('-ktx'))) {
-                setModified(Document.updateGradle(source, ['plugins'], "id 'kotlin-android'", { multiple: true }));
-            }
             const match = REGEXP_DEPENDENCIES.exec(source);
             if (match) {
-                const newLine = (0, util_1.getNewline)(source);
+                const newLine = getNewline(source);
                 const gradleDir = path.join(this.baseDirectory, 'gradle');
                 const template = instance.findTemplate(gradleDir, "libs.versions.toml", { detect: true, subDir: language, throwsDoesNotExist: false });
+                const removeGroup = (id) => {
+                    for (let i = 0; i < items.length; ++i) {
+                        if (items[i][0] === id) {
+                            items.splice(i--, 1);
+                        }
+                    }
+                };
                 let content = match[1], named = false, versioning = false, indent;
-                if (template.localUri && template.source) {
+                for (const platform of content.matchAll(kotlin ? REGEXP_PLATFORM_KOTLIN : REGEXP_PLATFORM)) {
+                    const [group, name] = trimQuote(platform[1]).trim().split(':');
+                    if (name.endsWith('-bom')) {
+                        removeGroup(group);
+                    }
+                }
+                if (template.source && template.localUri && instance.canWrite(template.localUri, { ownPermissionOnly: true })) {
                     versioning = kotlin && versionCatalog !== false || !!versionCatalog;
                     if (versioning || template.existing) {
                         const libs = {};
                         const versions = {};
                         let config = template.source, catalog;
-                        while (catalog = REGEXP_VERSIONS.exec(config)) {
-                            versions[catalog[1]] = (catalog[2] || catalog[3] || catalog[4]).trim();
+                        for (const ref of config.matchAll(REGEXP_VERSIONS)) {
+                            versions[ref[1]] = (ref[2] || ref[3] || ref[4]).trim();
                         }
                         while (catalog = REGEXP_VERSIONS_LIB.exec(config)) {
                             const lib = {};
@@ -272,6 +289,10 @@ function finalize(instance) {
                                 [group, name] = lib.module.split(':');
                             }
                             if (group && name) {
+                                if (name.endsWith('-bom')) {
+                                    removeGroup(group);
+                                    continue;
+                                }
                                 const index = items.findIndex(seg => seg[0] === group && seg[1] === name);
                                 if (index !== -1) {
                                     const item = items[index];
@@ -280,15 +301,15 @@ function finalize(instance) {
                                     const version = ref ? versions[ref] : lib.version;
                                     if (version && checkVersion(item, version)) {
                                         if (ref) {
-                                            const target = new RegExp(`\\s${(0, types_1.escapePattern)(ref)}\\s*=\\s*(?:"([^":]+)"|'([^':]+)')`, 'd').exec(config);
-                                            if (target) {
+                                            const target = new RegExp(`\\s${escapePattern(ref)}\\s*=\\s*(?:"([^"]+)"|'([^']+)')`, 'd').exec(config);
+                                            if (target?.indices) {
                                                 const [start, end] = target.indices[1] || target.indices[2];
-                                                config = (0, util_1.spliceString)(config, start, end, versions[ref] = item[2], REGEXP_VERSIONS_LIB);
+                                                config = spliceString(config, start, end, versions[ref] = item[2], REGEXP_VERSIONS_LIB);
                                             }
                                         }
                                         else if (lib.version_indices) {
                                             const [start, end] = lib.version_indices;
-                                            config = (0, util_1.spliceString)(config, start, end, lib.version = item[2], REGEXP_VERSIONS_LIB);
+                                            config = spliceString(config, start, end, lib.version = item[2], REGEXP_VERSIONS_LIB);
                                         }
                                     }
                                 }
@@ -297,12 +318,11 @@ function finalize(instance) {
                         }
                         if (versioning && items.length > 0) {
                             let output = '[libraries]' + newLine, outputVer = '';
-                            for (let i = 0, length = items.length; i < length; ++i) {
-                                const item = items[i];
+                            for (const item of items) {
                                 const [group, name, version] = item;
-                                let key = group.replaceAll('.', '-');
+                                let key = group.replace(/\./g, '-');
                                 if (libs[key]) {
-                                    key += '-' + name.replaceAll('.', '-');
+                                    key += '-' + name.replace(/\./g, '-');
                                 }
                                 let versionRef;
                                 found: {
@@ -316,8 +336,6 @@ function finalize(instance) {
                                             }
                                         }
                                     }
-                                }
-                                if (!versionRef) {
                                     if (versions[versionRef = toCamelCase(name)]) {
                                         const prefix = group.split('.').filter(seg => seg !== name).pop();
                                         if (prefix) {
@@ -325,9 +343,9 @@ function finalize(instance) {
                                         }
                                         else {
                                             const baseRef = versionRef;
-                                            let j = 1;
+                                            let i = 1;
                                             do {
-                                                versionRef = baseRef + j++;
+                                                versionRef = baseRef + i++;
                                             } while (versions[versionRef]);
                                         }
                                     }
@@ -335,7 +353,7 @@ function finalize(instance) {
                                     outputVer += versionRef + ` = "${version}"` + newLine;
                                 }
                                 output += key + ` = { group = "${group}", name = "${name}", version.ref = "${versionRef}" }` + newLine;
-                                item[0] = 'libs.' + key.replaceAll('-', '.');
+                                item[0] = 'libs.' + key.replace(/-/g, '.');
                                 item[1] = '';
                                 item[2] = '';
                                 libs[key] = { group, name, "version.ref": versionRef };
@@ -354,7 +372,7 @@ function finalize(instance) {
                             }
                             REGEXP_VERSIONS.lastIndex = 0;
                         }
-                        if (instance.canWrite(template.localUri, { ownPermissionOnly: true }) && Document.createDir(gradleDir)) {
+                        if (Document.createDir(gradleDir)) {
                             try {
                                 fs.writeFileSync(template.localUri, config, 'utf8');
                                 this.add(template.localUri);
@@ -373,16 +391,14 @@ function finalize(instance) {
                         let method;
                         while (method = pattern.exec(content)) {
                             let group, name, version;
-                            if ((0, types_1.isString)(method[1])) {
+                            if (isString(method[1])) {
                                 indent ||= method[1];
                             }
                             if (method[3]) {
                                 [group, name, version] = method[3].trim().split(/\s*:\s*/);
                             }
                             else if (method[4]) {
-                                const params = /(group|name|version)\s*[=:]\s*(?:"([^"]+)"|'([^']+)')/g;
-                                let param;
-                                while (param = params.exec(method[4])) {
+                                for (const param of method[4].matchAll(/(group|name|version)\s*[=:]\s*(?:"([^"]+)"|'([^']+)')/g)) {
                                     const value = (param[2] || param[3]).trim();
                                     switch (param[1]) {
                                         case 'group':
@@ -410,67 +426,51 @@ function finalize(instance) {
                                         version = '';
                                     }
                                     if (checkVersion(item, version, method[0])) {
-                                        content = (0, util_1.spliceString)(content, method.index, method.index + method[0].length, method[1] + writeMethod(kotlin, named, item, method[4], method[2]) + newLine, pattern);
+                                        content = spliceString(content, method.index, method.index + method[0].length, method[1] + writeMethod(kotlin, named, item, method[4], method[2]) + newLine, pattern);
                                         modified = true;
                                     }
                                 }
                             }
                         }
                     }
-                    indent ||= (0, util_1.getIndent)(match[1]);
+                    indent ||= getIndent(match[1]);
                     content = items.reduce((a, b) => a + indent + writeMethod(kotlin, named, b) + newLine, content);
                     modified = true;
                 }
                 setDependencies(match, content);
             }
-            if (items.some(seg => seg[0] === 'androidx.compose.ui')) {
-                let output = source;
-                if (kotlin) {
-                    output = Document.updateGradle(output, ['plugins'], 'kotlin("android")');
+            if (!kotlin && items.some(seg => seg[0] === 'androidx.compose.ui')) {
+                const stdLib = instance.findVersion('org.jetbrains.kotlin:kotlin-stdlib');
+                if (stdLib.startsWith('1.')) {
+                    let output = source;
                     output = Document.updateGradle(output, ['android', 'buildFeatures'], 'compose = true');
+                    output = Document.updateGradle(output, ['android', 'composeOptions'], `kotlinCompilerExtensionVersion = '${instance.findVersion('kotlinCompilerExtensionVersion', '1.5.15')}'`, updateOpts());
+                    setModified(output);
                 }
-                else {
-                    const stdLib = instance.findVersion('org.jetbrains.kotlin:kotlin-stdlib', "2.2.21");
-                    output = Document.updateGradle(output, ['plugins'], "id 'org.jetbrains.kotlin.android'", { upgrade: true, multiple: true, addendum: `version '${stdLib}'` });
-                    output = Document.updateGradle(output, ['android', 'buildFeatures'], "compose true");
-                    if (stdLib.startsWith('1.')) {
-                        output = Document.updateGradle(output, ['android', 'composeOptions'], `kotlinCompilerExtensionVersion '${instance.findVersion('kotlinCompilerExtensionVersion', "1.5.15")}'`, true);
-                    }
-                    if (upgrade) {
-                        output = Document.updateGradle(output, ['android', 'kotlinOptions'], `jvmTarget = '${javaVersion}'`, true);
-                    }
-                    else {
-                        output = Document.updateGradle(output, ['android', 'kotlinOptions'], "jvmTarget = '1.8'");
-                        jvmTarget = '1_8';
-                    }
-                }
-                setModified(output);
             }
         }
         if (libraries) {
             const match = REGEXP_DEPENDENCIES.exec(source);
             if (match) {
-                let content = match[1], method, indent;
-                const pattern = kotlin ? REGEXP_LIBRARY_KOTLIN : REGEXP_LIBRARY;
-                pattern.lastIndex = 0;
-                while (method = pattern.exec(content)) {
+                let content = match[1], indent;
+                for (const method of content.matchAll(kotlin ? REGEXP_LIBRARY_KOTLIN : REGEXP_LIBRARY)) {
                     const attr = (method[2] || method[4]);
-                    if ((0, types_1.isArray)(libraries[attr])) {
+                    if (isArray(libraries[attr])) {
                         let index = -1;
                         switch (attr) {
                             case 'project':
                             case 'files': {
-                                const pathname = (0, util_1.trimQuote)(method[3]);
+                                const pathname = trimQuote(method[3]);
                                 index = libraries[attr].findIndex(value => value === pathname);
                                 break;
                             }
                             case 'fileTree': {
-                                const dir = /"dir"\s+to\s+"(.+?)"(?:\s*,|$)/.exec(match[5])?.[1];
-                                const include = /"include"\s+to\s+listOf\((.+?)\)(?:\s*,|$)/.exec(match[5])?.[1];
+                                const dir = (kotlin ? /"dir"\s+to\s+"(.+)"(?:\s*,|$)/ : /\bdir\s*:\s*["'](.+)["'](?:\s*,|$)/).exec(match[5])?.[1];
+                                const include = (kotlin ? /"include"\s+to\s+listOf\(([^)]+)\)(?:\s*,|$)/ : /\binclude\s*:\s*\[(.+)\](?:\s*,|$)/).exec(match[5])?.[1];
                                 if (dir && include) {
                                     const compare = (from, orig) => {
                                         try {
-                                            return (0, types_1.isArray)(from) && from.sort().toString() === JSON.parse(`[${orig}]`).sort().toString();
+                                            return isArray(from) && from.sort().toString() === JSON.parse(`[${orig}]`).sort().toString();
                                         }
                                         catch {
                                             return false;
@@ -490,29 +490,29 @@ function finalize(instance) {
                         if (index !== -1) {
                             libraries[attr].splice(index, 1);
                         }
-                        if ((0, types_1.isString)(method[1])) {
+                        if (isString(method[1])) {
                             indent ||= method[1];
                         }
                     }
                 }
                 const { project, files, fileTree } = libraries;
-                if ((0, types_1.isArray)(project) || (0, types_1.isArray)(files) || (0, types_1.isArray)(fileTree)) {
-                    indent ||= (0, util_1.getIndent)(match[1]);
-                    const newLine = (0, util_1.getNewline)(source);
-                    const writeImpl = (name, value) => indent + 'implementation' + (kotlin ? `(${name}(${(0, util_1.wrapQuote)(value)}))` : ` ${name}(${(0, util_1.wrapQuote)(value)})`) + newLine;
-                    if ((0, types_1.isArray)(project)) {
+                if (isArray(project) || isArray(files) || isArray(fileTree)) {
+                    indent ||= getIndent(match[1]);
+                    const newLine = getNewline(source);
+                    const writeImpl = (name, value) => indent + 'implementation' + (kotlin ? `(${name}(${wrapQuote(value)}))` : ` ${name}(${wrapQuote(value)})`) + newLine;
+                    if (isArray(project)) {
                         content = project.reduce((a, b) => a + writeImpl('project', b), content);
                         modified = true;
                     }
-                    if ((0, types_1.isArray)(files)) {
+                    if (isArray(files)) {
                         content = files.reduce((a, b) => a + writeImpl('files', b), content);
                         modified = true;
                     }
-                    if ((0, types_1.isArray)(fileTree)) {
+                    if (isArray(fileTree)) {
                         for (const item of fileTree) {
-                            if ((0, types_1.isString)(item.dir) && (0, types_1.isArray)(item.include)) {
-                                const dir = (0, util_1.wrapQuote)(item.dir);
-                                const include = item.include.map(value => (0, util_1.wrapQuote)(value)).join(', ');
+                            if (isString(item.dir) && isArray(item.include)) {
+                                const dir = wrapQuote(item.dir);
+                                const include = item.include.map(value => wrapQuote(value)).join(', ');
                                 content += indent + 'implementation';
                                 if (kotlin) {
                                     content += `(fileTree(mapOf("dir" to ${dir}, "include" to listOf(${include}))))`;
@@ -529,68 +529,65 @@ function finalize(instance) {
                 }
             }
         }
-        if (upgrade || jvmTarget) {
-            const compatibility = 'JavaVersion.VERSION_' + (upgrade ? javaVersion.toString().replace(/\./g, '_') : jvmTarget);
+        if (upgrade) {
+            const compatibility = 'JavaVersion.VERSION_' + javaVersion.toString().replace(/\./g, '_');
+            const sourceCompat = valueFor('sourceCompatibility', compatibility, kotlin);
+            const targetCompat = valueFor('targetCompatibility', compatibility, kotlin);
             let output = source;
-            if (kotlin) {
-                output = Document.updateGradle(output, ['java'], 'sourceCompatibility = ' + compatibility, upgrade);
-                output = Document.updateGradle(output, ['java'], 'targetCompatibility = ' + compatibility, upgrade);
-                output = Document.updateGradle(output, ['android', 'kotlinOptions'], `jvmTarget = "${javaVersion}"`, upgrade);
+            output = Document.updateGradle(output, ['java'], sourceCompat, updateOpts(true));
+            if (output === source) {
+                output = Document.updateGradle(output, ['android', 'compileOptions'], sourceCompat, updateOpts());
+                output = Document.updateGradle(output, ['android', 'compileOptions'], targetCompat, updateOpts());
             }
             else {
-                output = Document.updateGradle(output, ['android', 'compileOptions'], 'sourceCompatibility ' + compatibility, upgrade);
-                output = Document.updateGradle(output, ['android', 'compileOptions'], 'targetCompatibility ' + compatibility, upgrade);
+                output = Document.updateGradle(output, ['java'], targetCompat, updateOpts(true));
             }
             setModified(output);
         }
         if (jvmToolchain) {
             let output = source;
             if (language === 'java') {
-                output = Document.updateGradle(output, ['java', 'toolchain'], kotlin ? `languageVersion.set(JavaLanguageVersion.of(${jvmToolchain}))` : `languageVersion = JavaLanguageVersion.of(${jvmToolchain})`, true);
+                output = Document.updateGradle(output, ['java', 'toolchain'], kotlin ? `languageVersion.set(JavaLanguageVersion.of(${jvmToolchain}))` : `languageVersion = JavaLanguageVersion.of(${jvmToolchain})`, updateOpts());
             }
             else {
-                output = Document.updateGradle(output, ['kotlin'], kotlin ? `jvmToolchain(${jvmToolchain})` : 'jvmToolchain ' + jvmToolchain, true);
+                output = Document.updateGradle(output, ['kotlin'], kotlin ? `jvmToolchain(${jvmToolchain})` : 'jvmToolchain ' + jvmToolchain, updateOpts());
             }
             setModified(output);
         }
-        if (!existing) {
-            const targetAPI = instance.targetAPI;
+        if (targetAPI) {
             let output = source;
-            if (targetAPI) {
-                const [compileSdk, targetSdk, updateOnly] = typeof targetAPI === 'string' ? [`"android-${targetAPI}"`, `"${targetAPI}"`, true] : [targetAPI, targetAPI, targetAPI >= 33];
-                let content = Document.updateGradle(output, ['android'], kotlin ? `compileSdkVersion(${compileSdk})` : 'compileSdkVersion ' + compileSdk, { upgrade: true, updateOnly });
-                if (content === output) {
-                    output = Document.updateGradle(output, ['android'], kotlin ? `compileSdk(${compileSdk})` : 'compileSdk ' + compileSdk, true);
-                }
-                else {
-                    output = content;
-                }
-                content = Document.updateGradle(output, ['android', 'defaultConfig'], kotlin ? `targetSdkVersion(${targetSdk})` : 'targetSdkVersion ' + targetSdk, { upgrade: true, updateOnly });
-                if (content === output) {
-                    output = Document.updateGradle(output, ['android', 'defaultConfig'], kotlin ? `targetSdk(${targetSdk})` : 'targetSdk ' + targetSdk, true);
-                }
-                else {
-                    output = content;
-                }
-                const version = instance.findVersion('buildToolsVersion');
-                if (version) {
-                    output = Document.updateGradle(output, ['android'], kotlin ? `buildToolsVersion = "${version}"` : `buildToolsVersion "${version}"`, true);
+            const tryInline = (compileSdk) => {
+                output = Document.updateGradle(output, ['android'], valueFor('compileSdk', compileSdk, kotlin), updateOpts(true));
+                return output !== source;
+            };
+            if (typeof targetAPI === 'number') {
+                const targetMajor = Math.floor(targetAPI);
+                output = Document.updateGradle(output, ['android', /version\s*=?\s*(release\(\d+\))/], [`release(${targetMajor})`, valueFor('minorApiLevel', Math.trunc((targetAPI - targetMajor) * 10), true)], updateOpts(true));
+                if (output === source) {
+                    tryInline(targetMajor);
                 }
             }
-            if (applicationId) {
-                output = Document.updateGradle(output, ['android', 'defaultConfig'], (kotlin ? 'applicationId = ' : 'applicationId ') + `"${applicationId}"`, true);
+            else if (tryInline(`"android-${targetAPI}"`)) {
+                output = Document.updateGradle(output, ['android', 'defaultConfig'], valueFor('targetSdk', targetAPI, kotlin, true), updateOpts());
+            }
+            const version = instance.findVersion('buildToolsVersion');
+            if (version) {
+                output = Document.updateGradle(output, ['android'], valueFor('buildToolsVersion', version, kotlin, true), updateOpts());
             }
             setModified(output);
         }
+        if (applicationId) {
+            setModified(Document.updateGradle(source, ['android', 'defaultConfig'], valueFor('applicationId', applicationId, kotlin, true), updateOpts()));
+        }
         if (dataBinding) {
-            setModified(Document.updateGradle(source, ['android', 'buildFeatures'], kotlin ? 'dataBinding = true' : 'dataBinding true', true));
+            setModified(Document.updateGradle(source, ['android', 'buildFeatures'], valueFor('dataBinding', 'true', true), updateOpts()));
         }
         if (namespace) {
-            setModified(Document.updateGradle(source, ['android'], (kotlin ? 'namespace = ' : 'namespace ') + `"${namespace}"`, true));
+            setModified(Document.updateGradle(source, ['android'], valueFor('namespace', namespace, true, true), updateOpts()));
         }
         if (profileable) {
             let name, items;
-            if ((0, types_1.isArray)(profileable)) {
+            if (isArray(profileable)) {
                 name = profileable[0];
                 if (typeof name === 'string' && !name.startsWith('--')) {
                     items = profileable.slice(1);
@@ -609,17 +606,17 @@ function finalize(instance) {
                 }
             }
             name ||= 'debug';
-            setModified(Document.updateGradle(source, ['android', 'buildTypes', kotlin ? 'getByName("release")' : 'release'], 'signingConfig ' + (kotlin ? `= signingConfigs.getByName("${name}")` : 'signingConfigs.' + name), true));
-            if ((0, types_1.isArray)(items)) {
+            setModified(Document.updateGradle(source, ['android', 'buildTypes', kotlin ? 'getByName("release")' : 'release'], 'signingConfig ' + (kotlin ? `= signingConfigs.getByName("${name}")` : 'signingConfigs.' + name), updateOpts()));
+            if (isArray(items)) {
                 const parameters = items.map(value => `"${value}"`).join(', ');
-                setModified(Document.updateGradle(source, ['android', 'aaptOptions'], 'additionalParameters ' + (kotlin ? `= [${parameters}]` : parameters), true));
+                setModified(Document.updateGradle(source, ['android', 'aaptOptions'], 'additionalParameters ' + (kotlin ? `= [${parameters}]` : parameters), updateOpts()));
             }
         }
         if (versionName) {
-            setModified(Document.updateGradle(source, ['android', 'defaultConfig'], (kotlin ? 'versionName = ' : 'versionName ') + `"${versionName}"`, true));
+            setModified(Document.updateGradle(source, ['android', 'defaultConfig'], valueFor('versionName', versionName, kotlin, true), updateOpts()));
         }
         if (versionCode) {
-            setModified(Document.updateGradle(source, ['android', 'defaultConfig'], (kotlin ? 'versionCode = ' : 'versionCode ') + versionCode, true));
+            setModified(Document.updateGradle(source, ['android', 'defaultConfig'], valueFor('versionCode', versionCode, kotlin), updateOpts()));
         }
         if (modified || !existing) {
             try {
@@ -678,4 +675,5 @@ function finalize(instance) {
         }
     }
 }
+
 module.exports = finalize;