@flakiness/junit-xml 1.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-2026 Degu Labs, Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,111 @@
+# @flakiness/junit-xml
+
+Convert JUnit XML test reports into a Flakiness report and upload it to [flakiness.io](https://flakiness.io). Parses Surefire and TestNG output, nested `<testsuites>`, retries, `<system-out>` / `<system-err>`, and file attachments.
+
+The recommended way to run it is with `npx` (no install step):
+
+```bash
+npx @flakiness/junit-xml ./build/reports/junit --flakiness-project myorg/myproject
+```
+
+This combines every XML file under the given path into a single Flakiness report and uploads it to flakiness.io.
+
+If your environment has no Node.js, a [standalone binary](#standalone-binary-no-nodejs) is also available.
+
+## Contents
+
+- [Usage](#usage)
+- [Example: ingesting `bun test` results](#example-ingesting-bun-test-results)
+- [Example: ingesting Rust `cargo-nextest` results](#example-ingesting-rust-cargo-nextest-results)
+- [Standalone binary (no Node.js)](#standalone-binary-no-nodejs)
+- [Uploading](#uploading)
+- [License](#license)
+
+## Usage
+
+```
+flakiness-junit-xml <junit-path> [options]
+
+  <junit-path>                   JUnit XML file, or a directory of XML files (scanned recursively)
+  --env-name <name>              Environment name (defaults to --category, or `junit`)
+  --commit-id <id>               Git commit ID (auto-detected from cwd if omitted)
+  --title <title>                Report title (env: FLAKINESS_TITLE)
+  --output-dir <dir>             Output directory (default: flakiness-report)
+  -c, --category <category>      Category, e.g. `bun`, `rust` (default: `junit`)
+  --flakiness-project <project>  Flakiness project, `org/project` (env: FLAKINESS_PROJECT)
+  --token <token>                Flakiness.io access token (env: FLAKINESS_ACCESS_TOKEN)
+  --endpoint <url>               Flakiness.io API endpoint override
+  --disable-upload               Convert only; don't upload (env: FLAKINESS_DISABLE_UPLOAD)
+```
+
+Requires Node.js `^20.17.0 || >=22.9.0`.
+
+`flakiness-junit-xml` ingests JUnit XML from **any** test runner. Some runners don't emit it by default — the examples below show how to get XML out of the common ones.
+
+## Example: ingesting `bun test` results
+
+`bun test` emits JUnit XML with `--reporter=junit`:
+
+```bash
+bun test --reporter=junit --reporter-outfile=./junit.xml
+npx @flakiness/junit-xml ./junit.xml --category bun --flakiness-project myorg/myproject
+```
+
+## Example: ingesting Rust `cargo-nextest` results
+
+`cargo test` doesn't emit JUnit XML; [`cargo-nextest`](https://nexte.st/) does. Add a CI profile in `.config/nextest.toml`:
+
+```toml
+[profile.ci.junit]
+path = "junit.xml"
+```
+
+Then run the tests and point at the XML nextest writes under `target/nextest/`:
+
+```bash
+cargo nextest run --profile ci
+npx @flakiness/junit-xml ./target/nextest/ci/junit.xml --category rust --flakiness-project myorg/myproject
+```
+
+## Standalone binary (no Node.js)
+
+A secondary distribution: a single self-contained executable that bundles its own runtime, so it works on machines without Node.js. The CLI, flags, and behavior are identical to the `npx` version — only the way you launch it differs.
+
+**macOS / Linux:**
+
+```bash
+curl -fsSL https://github.com/flakiness/junit-xml/releases/latest/download/install.sh | sh
+```
+
+**Windows (PowerShell):**
+
+```powershell
+irm https://github.com/flakiness/junit-xml/releases/latest/download/install.ps1 | iex
+```
+
+This installs a `flakiness-junit-xml` command on your `PATH`. Then use it exactly as above:
+
+```bash
+flakiness-junit-xml ./build/reports/junit --flakiness-project myorg/myproject
+```
+
+The installer detects your OS/architecture (x64 and arm64; Linux glibc and Alpine/musl) and always pulls the latest release. To pin a directory, set `INSTALL_DIR` (default `/usr/local/bin`):
+
+```bash
+curl -fsSL https://github.com/flakiness/junit-xml/releases/latest/download/install.sh | INSTALL_DIR="$HOME/.local/bin" sh
+```
+
+Prefer `npx` when Node.js is available — it's the primary, always-current path. Reach for the standalone binary only when Node.js isn't an option.
+
+## Uploading
+
+The report is uploaded to flakiness.io automatically. Authentication, in priority order:
+
+1. **Access token** — `--token` or `FLAKINESS_ACCESS_TOKEN`.
+2. **GitHub Actions OIDC** — no token needed when `--flakiness-project` (or `FLAKINESS_PROJECT`) is set, the project is bound to the repository, and the workflow grants `id-token: write`.
+
+To convert without uploading, pass `--disable-upload` or set `FLAKINESS_DISABLE_UPLOAD=1`. The report is still written to `--output-dir`.
+
+## License
+
+MIT

package/lib/cli.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import { CIUtils, GitWorktree, ReportUtils, uploadReport, writeReport } from "@flakiness/sdk";
+import { Command, Option } from "commander";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { parseJUnit } from "./parser.js";
+const STDERR_LOGGER = {
+  log: (...args) => console.error(...args),
+  warn: (...args) => console.error(...args),
+  error: (...args) => console.error(...args)
+};
+function envBool(name) {
+  return ["1", "true"].includes(process.env[name]?.toLowerCase() ?? "");
+}
+const program = new Command("flakiness-junit-xml").description("Convert JUnit XML report(s) to a Flakiness report and upload it to flakiness.io").argument("<junit-path>", "Path to a JUnit XML file or a directory containing XML files").option("--env-name <name>", "Environment name for the report (defaults to --category, or `junit` if neither is set)").option("--commit-id <id>", "Git commit ID (auto-detected from the current working directory if not provided)").addOption(new Option("--title <title>", "Human-readable report title").env("FLAKINESS_TITLE")).option("--output-dir <dir>", "Output directory for the report", "flakiness-report").option("-c, --category <category>", "Report category identifier (e.g. `bun`, `rust`). Defaults to `junit`.").addOption(new Option("--flakiness-project <project>", "Flakiness project identifier in `org/project` format").env("FLAKINESS_PROJECT")).addOption(new Option("-p, --project <org/project>").hideHelp()).addOption(new Option("--token <token>", "Flakiness.io access token for upload").env("FLAKINESS_ACCESS_TOKEN")).option("--endpoint <url>", "Flakiness.io API endpoint override").addOption(new Option("--disable-upload", "Convert only; do not upload to flakiness.io").env("FLAKINESS_DISABLE_UPLOAD")).action(async (junitPath, options) => {
+  await runConvert(junitPath, {
+    envName: options.envName ?? options.category ?? "junit",
+    outputDir: options.outputDir,
+    commitId: options.commitId,
+    title: options.title,
+    category: options.category,
+    flakinessProject: options.flakinessProject ?? options.project,
+    token: options.token,
+    endpoint: options.endpoint,
+    disableUpload: !!options.disableUpload
+  });
+});
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+async function runConvert(junitPath, options) {
+  const fullPath = path.resolve(junitPath);
+  if (!await exists(fullPath)) {
+    console.error(`Error: path ${fullPath} is not accessible`);
+    process.exit(1);
+  }
+  const stat = await fs.stat(fullPath);
+  const xmlContents = [];
+  if (stat.isFile()) {
+    xmlContents.push(await fs.readFile(fullPath, "utf-8"));
+  } else if (stat.isDirectory()) {
+    const xmlFiles = await findXmlFiles(fullPath);
+    if (xmlFiles.length === 0) {
+      console.error(`Error: No XML files found in directory ${fullPath}`);
+      process.exit(1);
+    }
+    console.log(`Found ${xmlFiles.length} XML file(s)`);
+    for (const xmlFile of xmlFiles)
+      xmlContents.push(await fs.readFile(xmlFile, "utf-8"));
+  } else {
+    console.error(`Error: ${fullPath} is neither a file nor a directory`);
+    process.exit(1);
+  }
+  let commitId;
+  if (options.commitId) {
+    commitId = options.commitId;
+  } else {
+    const result = GitWorktree.initialize(process.cwd());
+    if (!result.ok) {
+      console.error(`Failed to detect git commit (${result.error}). Please provide --commit-id.`);
+      process.exit(1);
+    }
+    commitId = result.commitId;
+  }
+  const { report, attachments } = await parseJUnit(xmlContents, {
+    commitId,
+    defaultEnv: ReportUtils.createEnvironment({ name: options.envName }),
+    runStartTimestamp: Date.now(),
+    runDuration: 0,
+    runUrl: CIUtils.runUrl(),
+    category: options.category
+  });
+  if (options.title)
+    report.title = options.title;
+  if (options.flakinessProject)
+    report.flakinessProject = options.flakinessProject;
+  await writeReport(report, attachments, options.outputDir);
+  console.log(`\u2713 Saved to ${options.outputDir}`);
+  const disableUpload = options.disableUpload || envBool("FLAKINESS_DISABLE_UPLOAD");
+  if (!disableUpload) {
+    await uploadReport(report, attachments, {
+      flakinessAccessToken: options.token,
+      flakinessEndpoint: options.endpoint,
+      logger: STDERR_LOGGER
+    });
+  }
+}
+async function exists(p) {
+  return fs.access(p, fs.constants.F_OK).then(() => true).catch(() => false);
+}
+async function findXmlFiles(dir, result = []) {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isFile() && entry.name.toLowerCase().endsWith(".xml"))
+      result.push(fullPath);
+    else if (entry.isDirectory())
+      await findXmlFiles(fullPath, result);
+  }
+  return result;
+}
+//# sourceMappingURL=cli.js.map

package/lib/parser.js

@@ -0,0 +1,238 @@
+import { FlakinessReport as FK } from "@flakiness/flakiness-report";
+import { ReportUtils } from "@flakiness/sdk";
+import { parseXml, XmlElement, XmlText } from "@rgrove/parse-xml";
+import assert from "assert";
+import fs from "fs";
+import mime from "mime";
+import path from "path";
+import { Temporal } from "temporal-polyfill";
+let gTZAbbreviationToIANATimezone;
+function tzAbbreviationToIANA(tz) {
+  if (!gTZAbbreviationToIANATimezone) {
+    gTZAbbreviationToIANATimezone = /* @__PURE__ */ new Map();
+    const probes = [/* @__PURE__ */ new Date("2026-06-15T12:00:00Z"), /* @__PURE__ */ new Date("2026-01-15T12:00:00Z")];
+    for (const tz2 of Intl.supportedValuesOf("timeZone")) {
+      for (const date of probes) {
+        const parts = new Intl.DateTimeFormat("en-US", { timeZone: tz2, timeZoneName: "short" }).formatToParts(date);
+        const abbr = parts.find((p) => p.type === "timeZoneName")?.value;
+        if (abbr)
+          gTZAbbreviationToIANATimezone.set(abbr, tz2);
+      }
+    }
+  }
+  return gTZAbbreviationToIANATimezone.get(tz);
+}
+function parseTimestamp(timestamp) {
+  const native = new Date(timestamp).getTime();
+  if (!isNaN(native))
+    return native;
+  const parts = timestamp.split(/\s+/);
+  const iana = parts.length === 2 ? tzAbbreviationToIANA(parts[1]) : void 0;
+  if (iana) {
+    const d = Temporal.PlainDateTime.from(parts[0]);
+    return d.toZonedDateTime(iana).epochMilliseconds;
+  }
+  throw new Error(`failed to parse timestamp: ${timestamp}`);
+}
+function getProperties(element) {
+  const propertiesNodes = element.children.filter((node) => node instanceof XmlElement).filter((node) => node.name === "properties");
+  if (!propertiesNodes.length)
+    return [];
+  const result = [];
+  for (const propertiesNode of propertiesNodes) {
+    const properties = propertiesNode.children.filter((node) => node instanceof XmlElement).filter((node) => node.name === "property");
+    for (const property of properties) {
+      const name = property.attributes["name"];
+      const innerText = property.children.find((node) => node instanceof XmlText);
+      const value = property.attributes["value"] ?? innerText?.text ?? "";
+      result.push([name, value]);
+    }
+  }
+  return result;
+}
+function extractErrors(testcase) {
+  const xmlErrors = testcase.children.filter((e) => e instanceof XmlElement).filter((element) => element.name === "error" || element.name === "failure");
+  if (!xmlErrors.length)
+    return void 0;
+  return xmlErrors.map((xmlErr) => parseError(xmlErr));
+}
+function parseError(xmlErr, explicitStackTrace) {
+  const stackTraceContainer = explicitStackTrace ? xmlErr.children.find((child) => child instanceof XmlElement && child.name === "stackTrace") : xmlErr;
+  const xmlStackNodes = stackTraceContainer?.children.filter((child) => child instanceof XmlText);
+  let stack = xmlStackNodes ? xmlStackNodes.map((node) => node.text).join("\n") : void 0;
+  let message = "";
+  let stackPrefix = "";
+  for (const token of [xmlErr.attributes["type"], xmlErr.attributes["message"]]) {
+    if (!token)
+      continue;
+    message = (message ? message + " " : "") + token;
+    if (!stack?.includes(token))
+      stackPrefix = (stackPrefix ? stackPrefix + " " : "") + token;
+  }
+  if (stack && stackPrefix)
+    stack = stackPrefix + "\n" + stack;
+  return {
+    message,
+    stack
+  };
+}
+function extractStdIO(testcase) {
+  const xmlStdio = testcase.children.filter((e) => e instanceof XmlElement).filter((element) => element.name === "system-out" || element.name === "system-err");
+  return xmlStdio.map((node) => {
+    return node.children.filter((child) => child instanceof XmlText).map((txtNode) => ({
+      stream: node.name === "system-out" ? FK.STREAM_STDOUT : FK.STREAM_STDERR,
+      text: txtNode.text,
+      dts: 0
+    }));
+  }).flat();
+}
+async function parseAttachment(value) {
+  let absolutePath = path.resolve(process.cwd(), value);
+  if (fs.existsSync(absolutePath))
+    return ReportUtils.createFileAttachment(mime.getType(absolutePath) ?? "image/png", absolutePath);
+  return ReportUtils.createDataAttachment("text/plain", Buffer.from(value));
+}
+async function traverseJUnitReport(context, node) {
+  const element = node;
+  if (!(element instanceof XmlElement))
+    return;
+  let { currentEnv, currentEnvIndex, currentSuite, report, currentTimeMs } = context;
+  if (element.attributes["timestamp"])
+    currentTimeMs = parseTimestamp(element.attributes["timestamp"]);
+  if (element.name === "testsuite") {
+    const file = element.attributes["file"];
+    const line = parseInt(element.attributes["line"], 10);
+    const name = element.attributes["name"];
+    const newSuite = {
+      title: name ?? file,
+      location: file && !isNaN(line) ? {
+        file,
+        line,
+        column: 1
+      } : void 0,
+      type: name ? "suite" : file ? "file" : "anonymous suite",
+      suites: [],
+      tests: []
+    };
+    if (currentSuite) {
+      currentSuite.suites ??= [];
+      currentSuite.suites.push(newSuite);
+    } else {
+      report.suites ??= [];
+      report.suites.push(newSuite);
+    }
+    currentSuite = newSuite;
+  } else if (element.name === "testcase") {
+    assert(currentSuite);
+    const file = element.attributes["file"];
+    const name = element.attributes["name"];
+    const line = parseInt(element.attributes["line"], 10);
+    const duration = parseFloat(element.attributes["time"]) * 1e3;
+    const annotations = [];
+    const attachments = [];
+    for (const [key, value] of getProperties(element)) {
+      if (key.toLowerCase().startsWith("attachment")) {
+        if (context.ignoreAttachments)
+          continue;
+        const attachment = await parseAttachment(value);
+        context.attachments.set(attachment.id, attachment);
+        attachments.push({
+          id: attachment.id,
+          contentType: attachment.contentType,
+          //TODO: better default names for attachments?
+          name: attachment.type === "file" ? path.basename(attachment.path) : `attachment`
+        });
+      } else {
+        annotations.push({
+          type: key,
+          description: value.length ? value : void 0
+        });
+      }
+    }
+    const childElements = element.children.filter((child) => child instanceof XmlElement);
+    const xmlSkippedAnnotation = childElements.find((child) => child.name === "skipped");
+    if (xmlSkippedAnnotation)
+      annotations.push({ type: "skipped", description: xmlSkippedAnnotation.attributes["message"] });
+    const expectedStatus = xmlSkippedAnnotation ? "skipped" : "passed";
+    const errors = extractErrors(element);
+    const test = {
+      title: name,
+      location: file && !isNaN(line) ? {
+        file,
+        line,
+        column: 1
+      } : void 0,
+      attempts: [{
+        environmentIdx: currentEnvIndex,
+        expectedStatus,
+        annotations,
+        attachments,
+        startTimestamp: 0,
+        duration,
+        status: xmlSkippedAnnotation ? "skipped" : errors ? "failed" : "passed",
+        errors,
+        stdio: extractStdIO(element)
+      }]
+    };
+    for (const rerun of element.children.filter((child) => child instanceof XmlElement && ["rerunFailure", "rerunError", "flakyError", "flakyFailure"].includes(child.name))) {
+      const duration2 = parseFloat(rerun.attributes["time"] || "0") * 1e3;
+      const attempt = {
+        environmentIdx: currentEnvIndex,
+        expectedStatus,
+        annotations,
+        startTimestamp: 0,
+        duration: duration2,
+        status: "failed",
+        errors: [parseError(rerun, "explicit-stack-trace")],
+        stdio: extractStdIO(rerun)
+      };
+      if (rerun.name.startsWith("flaky"))
+        test.attempts.splice(test.attempts.length - 1, 0, attempt);
+      else
+        test.attempts.push(attempt);
+    }
+    for (const attempt of test.attempts) {
+      attempt.startTimestamp = currentTimeMs;
+      currentTimeMs += attempt.duration;
+    }
+    currentSuite.tests ??= [];
+    currentSuite.tests.push(test);
+  }
+  context = { ...context, currentEnv, currentEnvIndex, currentSuite, currentTimeMs };
+  for (const child of element.children)
+    await traverseJUnitReport(context, child);
+}
+async function parseJUnit(xmls, options) {
+  const report = {
+    category: options.category ?? "junit",
+    commitId: options.commitId,
+    duration: options.runDuration,
+    startTimestamp: options.runStartTimestamp,
+    url: options.runUrl,
+    environments: [options.defaultEnv],
+    suites: [],
+    unattributedErrors: []
+  };
+  const context = {
+    currentEnv: options.defaultEnv,
+    currentEnvIndex: 0,
+    currentTimeMs: 0,
+    report,
+    currentSuite: void 0,
+    attachments: /* @__PURE__ */ new Map(),
+    ignoreAttachments: !!options.ignoreAttachments
+  };
+  for (const xml of xmls) {
+    const doc = parseXml(xml);
+    for (const element of doc.children)
+      await traverseJUnitReport(context, element);
+  }
+  return {
+    report: ReportUtils.normalizeReport(report),
+    attachments: Array.from(context.attachments.values())
+  };
+}
+export {
+  parseJUnit
+};
+//# sourceMappingURL=parser.js.map

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@flakiness/junit-xml",
+  "version": "1.0.0-alpha.0",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/flakiness/junit-xml.git"
+  },
+  "description": "Convert JUnit XML test reports into Flakiness Reports",
+  "bin": {
+    "flakiness-junit-xml": "lib/cli.js"
+  },
+  "scripts": {
+    "build": "kubik build.mts",
+    "watch": "kubik build.mts -w",
+    "test": "playwright test"
+  },
+  "keywords": [
+    "junit",
+    "junit-xml",
+    "surefire",
+    "testng",
+    "flakiness",
+    "testing",
+    "reporter"
+  ],
+  "author": "Degu Labs, Inc",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": "^20.17.0 || >=22.9.0"
+  },
+  "dependencies": {
+    "@flakiness/flakiness-report": "^0.34.0",
+    "@flakiness/sdk": "^3.2.0",
+    "@rgrove/parse-xml": "^4.2.0",
+    "commander": "^14.0.3",
+    "mime": "^4.1.0",
+    "temporal-polyfill": "^0.3.2"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.57.0",
+    "@types/node": "^25.0.3",
+    "esbuild": "^0.27.2",
+    "kubik": "^0.24.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/types/src/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/types/src/cli.d.ts.map

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

package/types/src/parser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This is largely based upon a nice writeup from here: https://github.com/testmoapp/junitxml
+ */
+import { FlakinessReport as FK } from '@flakiness/flakiness-report';
+import { ReportUtils } from '@flakiness/sdk';
+export declare function parseJUnit(xmls: string[], options: {
+    defaultEnv: FK.Environment;
+    commitId: FK.CommitId;
+    runDuration: FK.DurationMS;
+    runStartTimestamp: FK.UnixTimestampMS;
+    runUrl?: string;
+    ignoreAttachments?: boolean;
+    category?: string;
+}): Promise<{
+    report: FK.Report;
+    attachments: ReportUtils.Attachment[];
+}>;
+//# sourceMappingURL=parser.d.ts.map

package/types/src/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/parser.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,eAAe,IAAI,EAAE,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AA2P7C,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE;IACxD,UAAU,EAAE,EAAE,CAAC,WAAW,CAAC;IAC3B,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC;IACtB,WAAW,EAAE,EAAE,CAAC,UAAU,CAAC;IAC3B,iBAAiB,EAAE,EAAE,CAAC,eAAe,CAAC;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC;IAAC,WAAW,EAAE,WAAW,CAAC,UAAU,EAAE,CAAA;CAAE,CAAC,CA+BxE"}