@invarn/cibuild 2.6.7 → 2.6.9

package/dist/src/commands/android-java-version.test.js

@@ -29,10 +29,19 @@ describe('gradleJavaCeiling / gradleJavaFloor', () => {
     test('tracks what each Gradle line can run on', () => {
         expect(gradleJavaCeiling('4.10.2')).toBe(8);
         expect(gradleJavaCeiling('5.2.1')).toBe(11);
-        expect(gradleJavaCeiling('6.9')).toBe(15);
+        expect(gradleJavaCeiling('6.9')).toBe(11);
         expect(gradleJavaCeiling('7.6.1')).toBe(17);
         expect(gradleJavaCeiling('8.9')).toBe(21);
-        expect(gradleJavaCeiling('9.4.0')).toBe(24);
+        expect(gradleJavaCeiling('9.4.0')).toBe(25);
+    });
+    // The boundaries are minor releases, and preferring the newest JDK makes
+    // them load-bearing: JDK 21 arrived in Gradle 8.5, JDK 17 in 7.3, JDK 11 in
+    // 5.0.
+    test('knows the minor release each JDK arrived in', () => {
+        expect(gradleJavaCeiling('8.4')).toBe(17);
+        expect(gradleJavaCeiling('8.5')).toBe(21);
+        expect(gradleJavaCeiling('7.2')).toBe(11);
+        expect(gradleJavaCeiling('7.3')).toBe(17);
     });
     test('knows Gradle 9 dropped everything below 17', () => {
         expect(gradleJavaFloor('8.9')).toBe(8);
@@ -45,17 +54,32 @@ describe('gradleJavaCeiling / gradleJavaFloor', () => {
     });
 });
 describe('runnableJavaVersion', () => {
-    test('stays on the default when the default covers the declaration', () => {
-        // 11 is installed, but AGP 8.x cannot run on it — a project declaring
-        // sourceCompatibility 11 must still be built on 17.
-        expect(runnableJavaVersion(11)).toBe(17);
-        expect(runnableJavaVersion(17)).toBe(17);
-        expect(runnableJavaVersion(21)).toBe(21);
-    });
-    test('defaults to the preferred JDK when nothing is declared', () => {
-        expect(runnableJavaVersion(undefined)).toBe(17);
-    });
-    test('steps down to 11 only when the wrapper rules the default out', () => {
+    // DECIDED 2026-09-06 (Alex): the newest JDK the wrapper allows, reversing
+    // PRD decision #15. A declaration is a floor — 11 is installed, and a
+    // project declaring sourceCompatibility 11 gets 21, which it compiles
+    // perfectly well on and which AGP 8.x needs anyway.
+    test('takes the newest available JDK that covers the declaration', () => {
+        expect(runnableJavaVersion(11)).toBe(25);
+        expect(runnableJavaVersion(17)).toBe(25);
+        expect(runnableJavaVersion(25)).toBe(25);
+    });
+    test('takes the newest available JDK when nothing is declared', () => {
+        expect(runnableJavaVersion(undefined)).toBe(25);
+    });
+    // 8 joined the images on 2026-09-07 and must stay unreachable except where
+    // a wrapper ceiling forces it: a project declaring `sourceCompatibility 1.8`
+    // is declaring a floor, and AGP will not run on 8 at all.
+    test('never picks 8 for a project that merely declares it', () => {
+        // 8.13's own ceiling is 21 — JDK 25 needs Gradle 9.1.
+        expect(runnableJavaVersion(8, '8.13')).toBe(21);
+        expect(runnableJavaVersion(8)).toBe(25);
+    });
+    // AutoJs6: Gradle 4.10.2 tops out at Java 8, and now there is a Java 8.
+    test('picks 8 when the wrapper leaves nothing else', () => {
+        expect(runnableJavaVersion(undefined, '4.10.2')).toBe(8);
+        expect(runnableJavaVersion(8, '4.10.2')).toBe(8);
+    });
+    test('steps down to 11 only when the wrapper rules everything else out', () => {
         expect(runnableJavaVersion(undefined, '5.2.1')).toBe(11);
         expect(runnableJavaVersion(11, '5.2.1')).toBe(11);
         expect(runnableJavaVersion(undefined, '6.9')).toBe(11);
@@ -65,24 +89,29 @@ describe('runnableJavaVersion', () => {
         expect(AVAILABLE_JAVA_VERSIONS).toContain(runnableJavaVersion(25, '8.9'));
     });
     test('lets an old wrapper cap a newer declaration', () => {
-        // Gradle 7.x tops out at 17 even though 21 is installed.
-        expect(runnableJavaVersion(21, '7.6.1')).toBe(17);
+        // Gradle 7.x tops out at 17 even though newer JDKs are installed. There
+        // is no usable JDK at all, so the pipeline names the newest and the
+        // caller warns — `javaVersionProblem` is what says so.
+        expect(runnableJavaVersion(21, '7.6.1')).toBe(25);
+        expect(runnableJavaVersion(17, '7.6.1')).toBe(17);
     });
     test('honours the Gradle 9 floor of 17', () => {
-        expect(runnableJavaVersion(8, '9.0')).toBe(17);
+        // The floor rules 11 out; the newest above it is what gets written.
+        expect(runnableJavaVersion(8, '9.0')).toBe(21);
     });
 });
 describe('javaVersionProblem', () => {
-    test('names a Gradle version no installed JDK can run', () => {
-        // 4.10.2 tops out at Java 8, and no image carries 8.
-        const problem = javaVersionProblem(undefined, '4.10.2');
-        expect(problem).toContain('Gradle 4.10.2');
-        expect(problem).toContain('Java 8');
+    // There is no longer a Gradle version no installed JDK can run: the ceiling
+    // bottoms out at Java 8 and since 2026-09-07 the images carry one. The
+    // branch that says so is kept for an installed set that drops 8 again.
+    test('no longer calls an old wrapper a problem', () => {
+        expect(javaVersionProblem(undefined, '4.10.2')).toBeUndefined();
+        expect(javaVersionProblem(undefined, '3.5')).toBeUndefined();
     });
     test('names a declaration above every installed JDK', () => {
-        const problem = javaVersionProblem(23, '8.9');
-        expect(problem).toContain('Java 23');
-        expect(problem).toContain('11, 17 and 21');
+        const problem = javaVersionProblem(30, '8.9');
+        expect(problem).toContain('Java 30');
+        expect(problem).toContain('8, 11, 17, 21 and 25');
     });
     test('is silent when every constraint was honoured', () => {
         expect(javaVersionProblem(17, '8.9')).toBeUndefined();
@@ -90,6 +119,8 @@ describe('javaVersionProblem', () => {
         expect(javaVersionProblem(undefined, undefined)).toBeUndefined();
         // 5.2.1 used to be a problem. The images carry 11 now, so it is not.
         expect(javaVersionProblem(undefined, '5.2.1')).toBeUndefined();
+        // Nor is 4.10.2, since the images carry 8.
+        expect(javaVersionProblem(undefined, '4.10.2')).toBeUndefined();
     });
 });
 //# sourceMappingURL=android-java-version.test.js.map

package/dist/src/commands/android-scanner-java.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=android-scanner-java.test.d.ts.map

package/dist/src/commands/android-scanner-java.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"android-scanner-java.test.d.ts","sourceRoot":"","sources":["../../../src/commands/android-scanner-java.test.ts"],"names":[],"mappings":""}

package/dist/src/commands/android-scanner-java.test.js

@@ -0,0 +1,130 @@
+/**
+ * Which JDK a project needs, from every place it says so.
+ *
+ * Two rows of the thirty-app study died at root-project configuration on a
+ * JDK the images already carry, and neither was a repository problem:
+ *
+ *  - `SimonSchubert/LinuxCommandLibrary` declares eight modules in a single
+ *    `include(...)` call. The scanner's own include regex captured only the
+ *    first argument, so seven modules were never opened — including the one
+ *    with `jvmToolchain(21)` in it. It answered 17, and a Gradle plugin
+ *    requiring a 21 runtime failed the build.
+ *  - `mihonapp/mihon` declares no Java level in any Gradle file. It pins 21
+ *    in `.github/.java-version`, which its own workflows consume through
+ *    `setup-java`'s `java-version-file:`. Nothing of ours read either.
+ */
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { scanAndroidProject } from "./android-scanner.js";
+let root;
+beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "cibuild-java-"));
+});
+afterEach(() => {
+    rmSync(root, { recursive: true, force: true });
+});
+function write(relative, content) {
+    const path = join(root, relative);
+    mkdirSync(join(path, ".."), { recursive: true });
+    writeFileSync(path, content);
+}
+async function detectedJava() {
+    const result = await scanAndroidProject(root);
+    return result.detectedJavaVersion;
+}
+describe("the Java version a project asks for", () => {
+    describe("every module the build includes", () => {
+        // The exact settings line from LinuxCommandLibrary, and the two build
+        // files that decide the answer: 17 in the first module, 21 in the last.
+        test("reads all eight modules of one include call", async () => {
+            write("settings.gradle.kts", 'include(":android", ":common", ":websiteBuilder", ":cli", ":composeApp", ":desktopApp", ":viewmodels", ":screenshotTests")\n');
+            write("build.gradle.kts", "// root\n");
+            write("android/build.gradle.kts", "kotlin {\n  compilerOptions {\n    jvmTarget.set(JvmTarget.JVM_17)\n  }\n}\n");
+            write("screenshotTests/build.gradle.kts", "kotlin {\n  jvmToolchain(21)\n}\n");
+            expect(await detectedJava()).toBe(21);
+        });
+        test("reads the Groovy multi-argument form too", async () => {
+            write("settings.gradle", "include ':app', ':feature:home'\n");
+            write("app/build.gradle", "android { compileOptions { sourceCompatibility JavaVersion.VERSION_17 } }\n");
+            write("feature/home/build.gradle", "kotlin { jvmToolchain(21) }\n");
+            expect(await detectedJava()).toBe(21);
+        });
+        // A7 lite: a convention plugin's own build file is where a monorepo's
+        // Java level often lives, and `includeBuild` is how it gets there.
+        test("follows includeBuild into a build-logic root", async () => {
+            write("settings.gradle.kts", 'includeBuild("build-logic")\ninclude(":app")\n');
+            write("app/build.gradle.kts", "// nothing\n");
+            write("build-logic/build.gradle.kts", "kotlin { jvmToolchain(21) }\n");
+            expect(await detectedJava()).toBe(21);
+        });
+    });
+    describe("the forms a Kotlin build writes jvmTarget in", () => {
+        test.each([
+            ["jvmTarget.set(JvmTarget.JVM_17)", 17],
+            ["jvmTarget = JvmTarget.JVM_21", 21],
+            ['jvmTarget.set(JvmTarget.fromTarget("17"))', 17],
+            ['jvmTarget = "21"', 21],
+            ["jvmTarget.set(JvmTarget.JVM_1_8)", 8],
+        ])("reads %s", async (form, expected) => {
+            write("settings.gradle.kts", 'include(":app")\n');
+            write("app/build.gradle.kts", `kotlin { compilerOptions { ${form} } }\n`);
+            expect(await detectedJava()).toBe(expected);
+        });
+    });
+    describe("the files that pin a JDK outside Gradle", () => {
+        // mihon. The floor is 21 and no Gradle file says anything at all.
+        test("reads .github/.java-version", async () => {
+            write("settings.gradle.kts", 'include(":app")\n');
+            write("app/build.gradle.kts", "// nothing\n");
+            write(".github/.java-version", "21\n");
+            expect(await detectedJava()).toBe(21);
+        });
+        // thunderbird pins at the root.
+        test("reads a root .java-version", async () => {
+            write("settings.gradle.kts", 'include(":app")\n');
+            write(".java-version", "21\n");
+            expect(await detectedJava()).toBe(21);
+        });
+        test("reads a java entry in .tool-versions", async () => {
+            write("settings.gradle.kts", 'include(":app")\n');
+            write(".tool-versions", "nodejs 20.11.0\njava temurin-21.0.3+9\n");
+            expect(await detectedJava()).toBe(21);
+        });
+        test("reads .sdkmanrc", async () => {
+            write("settings.gradle.kts", 'include(":app")\n');
+            write(".sdkmanrc", "# comment\njava=17.0.9-tem\ngradle=8.13\n");
+            expect(await detectedJava()).toBe(17);
+        });
+        test("reads java-version from a workflow", async () => {
+            write("settings.gradle.kts", 'include(":app")\n');
+            write(".github/workflows/build.yml", "jobs:\n  build:\n    steps:\n      - uses: actions/setup-java@v4\n        with:\n          java-version: 21\n");
+            expect(await detectedJava()).toBe(21);
+        });
+        // A matrix declares several; the highest is the one that has to work.
+        test("takes the highest of a workflow matrix", async () => {
+            write("settings.gradle.kts", 'include(":app")\n');
+            write(".github/workflows/ci.yml", "strategy:\n  matrix:\n    java-version: [17, 21]\n");
+            expect(await detectedJava()).toBe(21);
+        });
+        // A pin is a floor, not a ceiling, and a Gradle declaration above it wins.
+        test("is a floor, not an override", async () => {
+            write("settings.gradle.kts", 'include(":app")\n');
+            write("app/build.gradle.kts", "kotlin { jvmToolchain(21) }\n");
+            write(".java-version", "17\n");
+            expect(await detectedJava()).toBe(21);
+        });
+        test("says nothing when nothing pins anything", async () => {
+            write("settings.gradle.kts", 'include(":app")\n');
+            write("app/build.gradle.kts", "// nothing\n");
+            expect(await detectedJava()).toBeUndefined();
+        });
+        // A version this scanner cannot make sense of must not become a number.
+        test("ignores an unreadable pin", async () => {
+            write("settings.gradle.kts", 'include(":app")\n');
+            write(".java-version", "graalvm-community\n");
+            expect(await detectedJava()).toBeUndefined();
+        });
+    });
+});
+//# sourceMappingURL=android-scanner-java.test.js.map

package/dist/src/commands/android-scanner.d.ts

@@ -44,6 +44,26 @@ export interface BuildVariants {
  * losing a real declaration is worse than keeping a guarded one.
  */
 export declare function stripExistenceGuardedBlocks(content: string): string;
+/** The builds a settings file composes in, e.g. `includeBuild("build-logic")`. */
+export declare function parseIncludedBuilds(content: string): string[];
+/**
+ * A Java version pinned outside Gradle, and the file that pins it.
+ *
+ * `mihonapp/mihon` declares no Java level in any Gradle file and pins 21 in
+ * `.github/.java-version`, which its own workflows consume through
+ * `setup-java`'s `java-version-file:`. The project says what it needs; it
+ * just does not say it in Gradle, and reading only Gradle files scanned it as
+ * "nothing declared" and ran it on the default. Across the thirty clones,
+ * three repositories pin with a version file and ten name a version in a
+ * workflow.
+ *
+ * A pin is a **floor**, folded in with `Math.max` like every other
+ * declaration — not an override.
+ */
+export declare function detectPinnedJavaVersion(root: string): {
+    version: number;
+    source: string;
+} | undefined;
 /**
  * The Gradle version a wrapper pins, read out of its `distributionUrl`.
  * `…/gradle-8.9-bin.zip` → `8.9`.
@@ -70,35 +90,40 @@ export declare function gradleJavaFloor(gradleVersion: string | undefined): numb
  *
  * 11 joined the images on 2026-09-05, for Gradle 5.x and 6.x — which cannot
  * *start* on 17, whatever the sources declare. It is a fallback, never a
- * preference; see `PREFERRED_JAVA_VERSION`.
+ * preference: the selection takes the newest JDK that fits, so 11 is reached
+ * only when a wrapper's ceiling leaves nothing else.
+ *
+ * 8 and 25 joined on 2026-09-07, the companion half of the "newest the
+ * wrapper allows" decision — the images carry every JDK we find a project
+ * asking for, rather than a project bending to what they carry. 8 is 11's
+ * argument one line further back (Gradle 4.x tops out at Java 8); 25 covers
+ * the six repositories in the 150-repo corpus that declare a level above 21.
+ * Nothing reaches 8 unless a wrapper ceiling forces it.
  */
 export declare const AVAILABLE_JAVA_VERSIONS: number[];
 /**
- * The JDK to write whenever nothing forces otherwise.
- *
- * This is what makes 11 safe to list. The selection below used to answer with
- * the *lowest* usable JDK, which was harmless while the lowest was 17. With 11
- * installed that rule would write `JAVA_VERSION: 11` for every project whose
- * `sourceCompatibility` is 11 — and AGP 8.x will not run on JDK 11, so
- * pipelines that build today would stop building.
+ * The newest JDK a build machine carries. Named because it is what a
+ * generated pipeline falls back to when no JDK can satisfy the constraints —
+ * a pipeline has to write something, and `javaVersionProblem` says what was
+ * given up.
  */
-export declare const PREFERRED_JAVA_VERSION = 17;
+export declare const NEWEST_AVAILABLE_JAVA_VERSION: number;
 /**
- * The Java version to write into a generated pipeline: `PREFERRED_JAVA_VERSION`
- * whenever it satisfies both what the sources declare and what the Gradle
- * wrapper can run on, and the nearest available JDK that does when it cannot.
+ * The Java version to write into a generated pipeline: the **newest**
+ * available JDK that satisfies both what the sources declare and what the
+ * Gradle wrapper can run on.
  *
- * Source compatibility is a floor, not an exact request — a project
- * declaring 11 compiles fine on 17 — but it is not the only constraint.
- * Gradle starts before it reads a single `sourceCompatibility`, so a wrapper
- * pinning an old Gradle caps the JDK no matter what the sources say, and a
- * declaration above every installed JDK cannot be honoured at all.
+ * DECIDED 2026-09-06 (Alex), reversing Invarn PRD decision #15 ("17 is the
+ * JDK whenever nothing forces otherwise"). The thirty-app study measured the
+ * cost of preferring 17 in one direction and none in the other: two rows
+ * failed because 17 was too *low* for a build plugin's own runtime
+ * requirement, and no row failed because 21 was too high. A project targeting
+ * 17 runs fine on 21; never the reverse.
  *
- * Falls back to the preferred JDK — not the lowest — when the constraints
- * cannot all be met, because a pipeline has to name something and the
- * unsatisfiable cases are overwhelmingly "declared something newer than we
- * have", where 17 is a far better guess than 11. `javaVersionProblem` says
- * what was given up so the caller can warn.
+ * Source compatibility is a floor, not an exact request. Gradle starts before
+ * it reads a single `sourceCompatibility`, so a wrapper pinning an old Gradle
+ * caps the JDK no matter what the sources say — which is why the ceiling
+ * above had to learn minor versions before this could ship.
  */
 export declare function runnableJavaVersion(detectedJavaVersion: number | undefined, gradleVersion?: string): number;
 /**

package/dist/src/commands/android-scanner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"android-scanner.d.ts","sourceRoot":"","sources":["../../../src/commands/android-scanner.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,MAAM,CAAC;AAEjD,MAAM,MAAM,eAAe,GACvB,cAAc,GACd,SAAS,GACT,iBAAiB,GACjB,gBAAgB,GAChB,cAAc,GACd,UAAU,GACV,gBAAgB,CAAC;AAErB,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,+EAA+E;IAC/E,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,uFAAuF;IACvF,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,2FAA2F;IAC3F,aAAa,EAAE,aAAa,CAAC;CAC9B;AAED,MAAM,WAAW,aAAa;IAC5B,gGAAgG;IAChG,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,wFAAwF;IACxF,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,uFAAuF;IACvF,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AA+JD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAcnE;AAoKD;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG7E;AAQD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CASvF;AAED,oEAAoE;AACpE,wBAAgB,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAIrF;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,UAAe,CAAC;AAEpD;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CACjC,mBAAmB,EAAE,MAAM,GAAG,SAAS,EACvC,aAAa,CAAC,EAAE,MAAM,GACrB,MAAM,CAYR;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,mBAAmB,EAAE,MAAM,GAAG,SAAS,EACvC,aAAa,CAAC,EAAE,MAAM,GACrB,MAAM,GAAG,SAAS,CAkBpB;AA6FD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,aAAa,CAmCxE;AAMD,wBAAsB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA4PjF;AAgBD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAyD3D"}
+{"version":3,"file":"android-scanner.d.ts","sourceRoot":"","sources":["../../../src/commands/android-scanner.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,MAAM,CAAC;AAEjD,MAAM,MAAM,eAAe,GACvB,cAAc,GACd,SAAS,GACT,iBAAiB,GACjB,gBAAgB,GAChB,cAAc,GACd,UAAU,GACV,gBAAgB,CAAC;AAErB,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,+EAA+E;IAC/E,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,uFAAuF;IACvF,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,2FAA2F;IAC3F,aAAa,EAAE,aAAa,CAAC;CAC9B;AAED,MAAM,WAAW,aAAa;IAC5B,gGAAgG;IAChG,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,wFAAwF;IACxF,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,uFAAuF;IACvF,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAwKD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAcnE;AAyKD,kFAAkF;AAClF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAO7D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,GACX;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CA8CjD;AA2BD;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG7E;AAQD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAsBvF;AAED,oEAAoE;AACpE,wBAAgB,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAIrF;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,uBAAuB,UAAsB,CAAC;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,QAAuC,CAAC;AAElF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CACjC,mBAAmB,EAAE,MAAM,GAAG,SAAS,EACvC,aAAa,CAAC,EAAE,MAAM,GACrB,MAAM,CAQR;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,mBAAmB,EAAE,MAAM,GAAG,SAAS,EACvC,aAAa,CAAC,EAAE,MAAM,GACrB,MAAM,GAAG,SAAS,CAkBpB;AA6FD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,aAAa,CAmCxE;AAMD,wBAAsB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAoQjF;AAgBD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAyD3D"}