circle-ir 3.32.0 → 3.34.0

package/dist/browser/circle-ir.js

@@ -9638,10 +9638,16 @@ var FRAMEWORK_MODULE_PATTERNS = [
   /^@nestjs\/core$/
 ];
 function extractRuntimeRegistrations(tree, cache, language, imports) {
-  if (language !== "javascript" && language !== "typescript") {
-    return [];
+  if (language === "javascript" || language === "typescript") {
+    return extractJSRuntimeRegistrations(tree, cache, imports);
+  }
+  if (language === "python") {
+    return extractPythonRuntimeRegistrations(tree, cache, imports);
+  }
+  if (language === "rust") {
+    return extractRustRuntimeRegistrations(tree, cache);
   }
-  return extractJSRuntimeRegistrations(tree, cache, imports);
+  return [];
 }
 function buildHandlerIndex(tree, cache, imports) {
   const decls = /* @__PURE__ */ new Map();
@@ -9811,6 +9817,494 @@ function resolveHandler(node, index) {
   }
   return null;
 }
+var PY_HTTP_ROUTE_METHODS = /* @__PURE__ */ new Set([
+  // Flask/Blueprint: app.route, blueprint.route, api.route
+  "route",
+  // FastAPI / Starlette / DRF method-specific
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "head",
+  "options"
+  // Flask aliases (Flask 2.x): app.get/post/...
+]);
+var PY_MIDDLEWARE_METHODS = /* @__PURE__ */ new Set([
+  "before_request",
+  "after_request",
+  "teardown_request",
+  "before_first_request",
+  "teardown_appcontext",
+  // Starlette / FastAPI
+  "middleware"
+]);
+var PY_EVENT_METHODS = /* @__PURE__ */ new Set([
+  "errorhandler",
+  "on_event",
+  "exception_handler"
+  // Celery beat etc — not strictly events but lifecycle
+]);
+var PY_STDLIB_DECORATORS = /* @__PURE__ */ new Set([
+  "property",
+  "staticmethod",
+  "classmethod",
+  "abstractmethod",
+  "cached_property",
+  "dataclass",
+  "cache",
+  "lru_cache",
+  "singledispatch",
+  "singledispatchmethod",
+  "contextmanager",
+  "asynccontextmanager",
+  "final",
+  "override",
+  "wraps"
+]);
+function summarisePythonImports(imports) {
+  const s = {
+    hasFlask: false,
+    hasFastApi: false,
+    hasCelery: false,
+    hasNumba: false,
+    hasClick: false,
+    hasPytest: false
+  };
+  if (!imports) return s;
+  for (const imp of imports) {
+    const mod = imp.from_package ?? "";
+    if (!mod) continue;
+    if (/^flask(\b|\.)/.test(mod)) s.hasFlask = true;
+    if (/^fastapi(\b|\.)/.test(mod) || /^starlette(\b|\.)/.test(mod)) s.hasFastApi = true;
+    if (/^celery(\b|\.)/.test(mod)) s.hasCelery = true;
+    if (/^numba(\b|\.)/.test(mod)) s.hasNumba = true;
+    if (/^click(\b|\.)/.test(mod)) s.hasClick = true;
+    if (/^pytest(\b|\.)/.test(mod)) s.hasPytest = true;
+  }
+  return s;
+}
+function extractPythonRuntimeRegistrations(tree, cache, imports) {
+  const out2 = [];
+  const importSummary = summarisePythonImports(imports);
+  const decoratedDefs = getNodesFromCache(tree.rootNode, "decorated_definition", cache);
+  for (const dd of decoratedDefs) {
+    let fnNode = null;
+    const decorators = [];
+    for (let i2 = 0; i2 < dd.childCount; i2++) {
+      const child = dd.child(i2);
+      if (!child) continue;
+      if (child.type === "decorator") {
+        decorators.push(child);
+      } else if (child.type === "function_definition" || child.type === "async_function_definition") {
+        fnNode = child;
+      }
+    }
+    if (!fnNode || decorators.length === 0) continue;
+    const handler = pythonHandlerFromFunctionDef(fnNode);
+    if (!handler) continue;
+    for (const dec of decorators) {
+      const parsed = parsePythonDecorator(dec);
+      if (!parsed) continue;
+      const { receiver, method, path, line, column } = parsed;
+      const { kind, framework } = classifyPythonDecorator(
+        receiver,
+        method,
+        importSummary
+      );
+      out2.push({
+        kind,
+        framework,
+        registrar: { method, receiver, line, column },
+        ...path !== void 0 ? { path } : {},
+        handler
+      });
+    }
+  }
+  return out2;
+}
+function pythonHandlerFromFunctionDef(fn) {
+  const nameNode = fn.childForFieldName("name");
+  if (!nameNode) return null;
+  return {
+    name: getNodeText(nameNode),
+    line: fn.startPosition.row + 1,
+    column: fn.startPosition.column
+  };
+}
+function parsePythonDecorator(dec) {
+  let target = null;
+  for (let i2 = 0; i2 < dec.childCount; i2++) {
+    const child = dec.child(i2);
+    if (!child || child.type === "@") continue;
+    target = child;
+    break;
+  }
+  if (!target) return null;
+  const line = dec.startPosition.row + 1;
+  const column = dec.startPosition.column;
+  if (target.type === "identifier") {
+    return { receiver: "", method: getNodeText(target), line, column };
+  }
+  if (target.type === "attribute") {
+    const { receiver, method } = splitDottedAttribute(target);
+    return { receiver, method, line, column };
+  }
+  if (target.type === "call") {
+    const fnNode = target.childForFieldName("function");
+    if (!fnNode) return null;
+    let receiver = "";
+    let method = "";
+    if (fnNode.type === "identifier") {
+      method = getNodeText(fnNode);
+    } else if (fnNode.type === "attribute") {
+      const split = splitDottedAttribute(fnNode);
+      receiver = split.receiver;
+      method = split.method;
+    } else {
+      method = getNodeText(fnNode);
+    }
+    const path = extractFirstStringArg(target);
+    return { receiver, method, path, line, column };
+  }
+  return null;
+}
+function splitDottedAttribute(attr) {
+  const objectNode = attr.childForFieldName("object");
+  const attrNode = attr.childForFieldName("attribute");
+  const method = attrNode ? getNodeText(attrNode) : "";
+  const receiver = objectNode ? getNodeText(objectNode) : "";
+  return { receiver, method };
+}
+function extractFirstStringArg(call) {
+  const argsNode = call.childForFieldName("arguments");
+  if (!argsNode) return void 0;
+  for (let i2 = 0; i2 < argsNode.childCount; i2++) {
+    const child = argsNode.child(i2);
+    if (!child) continue;
+    if (child.type === "(" || child.type === ")" || child.type === ",") continue;
+    if (child.type === "string") {
+      return stripPythonStringQuotes(getNodeText(child));
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function stripPythonStringQuotes(s) {
+  const m = s.match(/^[bBrRuUfF]{0,2}(['"])(.*)\1$/s);
+  if (m) return m[2];
+  if (s.length >= 2 && (s[0] === '"' || s[0] === "'") && s[s.length - 1] === s[0]) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function classifyPythonDecorator(receiver, method, imp) {
+  if (!receiver && PY_STDLIB_DECORATORS.has(method)) {
+    return { kind: "decorator", framework: "stdlib" };
+  }
+  if (receiver) {
+    const head = receiver.split(".")[0];
+    if (head === "pytest") {
+      return { kind: "decorator", framework: "pytest" };
+    }
+    if (head === "click") {
+      return { kind: "decorator", framework: "click" };
+    }
+    if (head === "numba" || head === "nb") {
+      return { kind: "decorator", framework: "numba" };
+    }
+    if (head === "celery") {
+      return { kind: "decorator", framework: "celery" };
+    }
+  }
+  if (receiver && PY_HTTP_ROUTE_METHODS.has(method)) {
+    const isRoutey = isPyRouterReceiver(receiver);
+    if (isRoutey) {
+      let framework = "unknown";
+      if (imp.hasFlask) framework = "flask";
+      else if (imp.hasFastApi) framework = "fastapi";
+      else if (method === "route") framework = "flask";
+      else framework = "fastapi";
+      return { kind: "http_route", framework };
+    }
+  }
+  if (receiver && PY_MIDDLEWARE_METHODS.has(method)) {
+    return { kind: "middleware", framework: imp.hasFlask ? "flask" : imp.hasFastApi ? "fastapi" : "unknown" };
+  }
+  if (receiver && PY_EVENT_METHODS.has(method)) {
+    return { kind: "event_listener", framework: imp.hasFlask ? "flask" : imp.hasFastApi ? "fastapi" : "unknown" };
+  }
+  if (method === "task" && imp.hasCelery) {
+    return { kind: "decorator", framework: "celery" };
+  }
+  if (!receiver && (method === "login_required" || method === "require_http_methods" || method === "api_view")) {
+    return { kind: "decorator", framework: "django" };
+  }
+  return { kind: "decorator", framework: "unknown" };
+}
+function isPyRouterReceiver(receiver) {
+  const head = receiver.split(".")[0];
+  if (!head) return false;
+  if (["app", "router", "blueprint", "bp", "api", "application"].includes(head)) return true;
+  if (/_(router|bp|blueprint|app|api)$/.test(head)) return true;
+  return false;
+}
+var RUST_STDLIB_TRAITS = /* @__PURE__ */ new Set([
+  // Formatting
+  "Display",
+  "Debug",
+  "Write",
+  // Conversion
+  "From",
+  "Into",
+  "TryFrom",
+  "TryInto",
+  "AsRef",
+  "AsMut",
+  "ToString",
+  "FromStr",
+  // Iteration
+  "Iterator",
+  "IntoIterator",
+  "FromIterator",
+  "DoubleEndedIterator",
+  "ExactSizeIterator",
+  "FusedIterator",
+  // Comparison + hashing
+  "PartialEq",
+  "Eq",
+  "PartialOrd",
+  "Ord",
+  "Hash",
+  // Markers + defaults
+  "Default",
+  "Copy",
+  "Clone",
+  "Send",
+  "Sync",
+  "Unpin",
+  "Sized",
+  "Any",
+  // Resource management
+  "Drop",
+  // Async
+  "Future",
+  "IntoFuture",
+  // Operators
+  "Add",
+  "Sub",
+  "Mul",
+  "Div",
+  "Rem",
+  "Neg",
+  "Not",
+  "AddAssign",
+  "SubAssign",
+  "MulAssign",
+  "DivAssign",
+  "RemAssign",
+  "BitAnd",
+  "BitOr",
+  "BitXor",
+  "Shl",
+  "Shr",
+  "Deref",
+  "DerefMut",
+  "Index",
+  "IndexMut",
+  // Closures
+  "Fn",
+  "FnMut",
+  "FnOnce",
+  // Error + I/O
+  "Error",
+  "Read",
+  "Write",
+  "Seek",
+  "BufRead",
+  // Misc
+  "Borrow",
+  "BorrowMut",
+  "ToOwned"
+]);
+var RUST_TRAIT_FRAMEWORK_PREFIXES = [
+  { prefix: /^actix(_web)?(::|$)/, framework: "actix" },
+  { prefix: /^axum(::|$)/, framework: "axum" },
+  { prefix: /^rocket(::|$)/, framework: "rocket" },
+  { prefix: /^tokio(::|$)/, framework: "tokio" },
+  { prefix: /^serde(_\w+)?(::|$)/, framework: "serde" },
+  { prefix: /^std(::|$)/, framework: "stdlib" },
+  { prefix: /^core(::|$)/, framework: "stdlib" },
+  { prefix: /^alloc(::|$)/, framework: "stdlib" }
+];
+function extractRustRuntimeRegistrations(tree, cache) {
+  const regs = [];
+  const implNodes = getNodesFromCache(tree.rootNode, "impl_item", cache);
+  for (const impl of implNodes) {
+    collectRustImplRegistrations(impl, regs);
+  }
+  const macroNodes = getNodesFromCache(tree.rootNode, "macro_invocation", cache);
+  for (const macro of macroNodes) {
+    const rec = parseInventorySubmit(macro);
+    if (rec) regs.push(rec);
+  }
+  const attrNodes = getNodesFromCache(tree.rootNode, "attribute_item", cache);
+  for (const attr of attrNodes) {
+    const rec = parseDistributedSliceAttribute(attr);
+    if (rec) regs.push(rec);
+  }
+  return regs;
+}
+function collectRustImplRegistrations(impl, regs) {
+  const traitNode = impl.childForFieldName("trait");
+  if (!traitNode) return;
+  const typeNode = impl.childForFieldName("type");
+  if (!typeNode) return;
+  const traitText = getNodeText(traitNode).trim();
+  const traitLastSegment = lastRustPathSegment(stripRustGenerics(traitText));
+  const selfType = getNodeText(typeNode).trim();
+  const framework = classifyRustTrait(traitText);
+  const body2 = impl.childForFieldName("body");
+  if (!body2) return;
+  for (let i2 = 0; i2 < body2.childCount; i2++) {
+    const child = body2.child(i2);
+    if (!child || child.type !== "function_item") continue;
+    const nameNode = child.childForFieldName("name");
+    if (!nameNode) continue;
+    const methodName = getNodeText(nameNode);
+    regs.push({
+      kind: "trait_impl",
+      framework,
+      registrar: {
+        method: methodName,
+        receiver: selfType,
+        line: impl.startPosition.row + 1,
+        column: impl.startPosition.column
+      },
+      path: traitLastSegment || traitText,
+      handler: {
+        name: methodName,
+        line: child.startPosition.row + 1,
+        column: child.startPosition.column
+      }
+    });
+  }
+}
+function stripRustGenerics(text) {
+  const idx = text.indexOf("<");
+  return idx >= 0 ? text.slice(0, idx) : text;
+}
+function lastRustPathSegment(path) {
+  const parts2 = path.split("::");
+  return parts2[parts2.length - 1] || path;
+}
+function classifyRustTrait(traitText) {
+  const stripped = stripRustGenerics(traitText).trim();
+  const last = lastRustPathSegment(stripped);
+  if (RUST_STDLIB_TRAITS.has(last)) return "stdlib";
+  for (const { prefix, framework } of RUST_TRAIT_FRAMEWORK_PREFIXES) {
+    if (prefix.test(stripped)) return framework;
+  }
+  return "unknown";
+}
+function parseInventorySubmit(macro) {
+  const macroName = macro.childForFieldName("macro");
+  if (!macroName) return null;
+  const name2 = getNodeText(macroName).trim();
+  if (name2 !== "inventory::submit" && name2 !== "submit") return null;
+  if (name2 === "submit") return null;
+  let tokenTree = null;
+  for (let i2 = 0; i2 < macro.childCount; i2++) {
+    const c = macro.child(i2);
+    if (c && c.type === "token_tree") {
+      tokenTree = c;
+      break;
+    }
+  }
+  if (!tokenTree) return null;
+  const handlerName = firstIdentifierInTokenTree(tokenTree);
+  return {
+    kind: "trait_impl",
+    framework: "inventory",
+    registrar: {
+      method: "submit",
+      receiver: "inventory",
+      line: macro.startPosition.row + 1,
+      column: macro.startPosition.column
+    },
+    path: "inventory::submit",
+    handler: {
+      name: handlerName,
+      line: tokenTree.startPosition.row + 1,
+      column: tokenTree.startPosition.column
+    }
+  };
+}
+function firstIdentifierInTokenTree(tokenTree) {
+  for (let i2 = 0; i2 < tokenTree.childCount; i2++) {
+    const c = tokenTree.child(i2);
+    if (!c) continue;
+    if (c.type === "identifier" || c.type === "scoped_identifier" || c.type === "type_identifier") {
+      return getNodeText(c).trim();
+    }
+  }
+  return null;
+}
+function parseDistributedSliceAttribute(attrItem) {
+  let attr = null;
+  for (let i2 = 0; i2 < attrItem.childCount; i2++) {
+    const c = attrItem.child(i2);
+    if (c && c.type === "attribute") {
+      attr = c;
+      break;
+    }
+  }
+  if (!attr) return null;
+  const pathNode = attr.child(0);
+  if (!pathNode) return null;
+  const pathText = getNodeText(pathNode).trim();
+  if (pathText !== "linkme::distributed_slice" && pathText !== "distributed_slice") return null;
+  const parent = attrItem.parent;
+  if (!parent) return null;
+  let attrIndex = -1;
+  for (let i2 = 0; i2 < parent.childCount; i2++) {
+    const c = parent.child(i2);
+    if (c && c.id === attrItem.id) {
+      attrIndex = i2;
+      break;
+    }
+  }
+  if (attrIndex < 0) return null;
+  let handlerNode = null;
+  for (let j = attrIndex + 1; j < parent.childCount; j++) {
+    const sib = parent.child(j);
+    if (!sib) continue;
+    if (sib.type === "attribute_item") continue;
+    if (sib.type === "static_item" || sib.type === "function_item") {
+      handlerNode = sib;
+    }
+    break;
+  }
+  if (!handlerNode) return null;
+  const nameNode = handlerNode.childForFieldName("name");
+  const handlerName = nameNode ? getNodeText(nameNode).trim() : null;
+  return {
+    kind: "trait_impl",
+    framework: "linkme",
+    registrar: {
+      method: "distributed_slice",
+      receiver: "linkme",
+      line: attrItem.startPosition.row + 1,
+      column: attrItem.startPosition.column
+    },
+    path: "linkme::distributed_slice",
+    handler: {
+      name: handlerName,
+      line: handlerNode.startPosition.row + 1,
+      column: handlerNode.startPosition.column
+    }
+  };
+}
 
 // src/analysis/config-loader.ts
 var DEFAULT_SOURCES = [
@@ -26316,7 +26810,9 @@ function getNodeTypesForLanguage(language) {
         "use_declaration",
         "let_declaration",
         "field_expression",
-        "scoped_identifier"
+        "scoped_identifier",
+        "attribute_item",
+        "static_item"
       ]);
     case "python":
       return /* @__PURE__ */ new Set([
@@ -26327,7 +26823,9 @@ function getNodeTypesForLanguage(language) {
         "import_from_statement",
         "assignment",
         "attribute",
-        "subscript"
+        "subscript",
+        "decorated_definition",
+        "decorator"
       ]);
     case "javascript":
     case "typescript":

package/dist/core/extractors/runtime-registrations.d.ts

@@ -1,25 +1,43 @@
 /**
- * Runtime-registration extractor (issue #15 — Phase 1).
+ * Runtime-registration extractor (issue #15 — Phases 1, 2, 3).
  *
- * Recognises JS/TS framework registration patterns where a handler is wired
- * into a dispatch table at module-load time. Static call extraction sees the
- * registration call (`app.get(...)`) but not the edge from registrar → handler.
+ * Recognises framework registration patterns where a handler is wired into a
+ * dispatch table at module-load time. Static call extraction sees the
+ * registration call/decorator but not the edge from registrar → handler.
  *
  * Downstream consumers (e.g. dead-code reachability) read
  * `ir.runtime_registrations` and add each resolved handler as a virtual entry
  * root, eliminating "unreachable" false positives for framework handlers.
  *
- * Phase 1 covers:
- *   - Express-family HTTP routes: `app.METHOD(path?, ...handlers)`
- *     where METHOD ∈ HTTP_VERBS and receiver is express-shaped
+ * Phase 1 — JS/TS Express-family (shipped 3.32.0):
+ *   - HTTP routes: `app.METHOD(path?, ...handlers)` for METHOD ∈ HTTP_VERBS
  *   - Middleware: `app.use(...handlers)`
- *   - Event listeners: `emitter.on('event', handler)` (when receiver is
- *     express-shaped, otherwise skipped to avoid false-positive registrations)
+ *   - Event listeners: `emitter.on('event', handler)` on express-shaped receivers
  *
- * Out of scope for Phase 1:
- *   - NestJS / Python decorators (Phase 2)
- *   - Rust trait dispatch (Phase 3)
- *   - Subapp mounting (`app.use('/api', subApp)`) handler resolution
+ * Phase 2 — Python decorators (3.33.0):
+ *   - Every `@decorator` on a function emits a registration with handler =
+ *     decorated function. Known frameworks are tagged (flask, fastapi,
+ *     django, click, pytest, celery, numba); built-in (property,
+ *     staticmethod, etc.) is tagged `stdlib`. Routing-style decorators
+ *     (`@app.route`, `@app.get`, `@router.post`) are classified as
+ *     `kind: 'http_route'` so downstream consumers can treat JS routes and
+ *     Python routes uniformly.
+ *
+ * Phase 3 — Rust trait dispatch (3.34.0):
+ *   - `impl Trait for Type { fn method(...) }` emits one `trait_impl`
+ *     registration per method, recording the Self type as `receiver`, the
+ *     trait path as `path`, and the method as both `registrar.method` and
+ *     `handler.name`. Stdlib traits (Display, Debug, Iterator, …) are tagged
+ *     `framework: 'stdlib'`; known web/async/serde frameworks (actix, axum,
+ *     rocket, tokio, serde) are tagged accordingly.
+ *   - `inventory::submit! { … }` and `#[linkme::distributed_slice]` emit
+ *     `trait_impl` registrations with framework `'inventory'` / `'linkme'`.
+ *
+ * Out of scope:
+ *   - Subapp mounting (`app.use('/api', subApp)`) handler resolution.
+ *   - Cross-file trait → impl resolution scoped by `Cargo.toml` reachability
+ *     (file-local impls only at extraction time; project-level resolution is
+ *     deferred to a later cross-file pass).
  */
 import type { Tree } from 'web-tree-sitter';
 import type { RuntimeRegistration, ImportInfo } from '../../types/index.js';
@@ -28,7 +46,9 @@ import type { SupportedLanguage } from '../parser.js';
 /**
  * Extract runtime-registration patterns from a parsed file.
  *
- * Returns `[]` for any language other than JavaScript/TypeScript in Phase 1.
+ * Phase 1 covers JavaScript/TypeScript. Phase 2 adds Python decorators.
+ * Phase 3 adds Rust trait dispatch (`impl Trait for Type`, `inventory::submit!`,
+ * `#[linkme::distributed_slice]`). Returns `[]` for any other language.
  */
 export declare function extractRuntimeRegistrations(tree: Tree, cache: NodeCache | undefined, language: SupportedLanguage | string, imports?: ImportInfo[]): RuntimeRegistration[];
 //# sourceMappingURL=runtime-registrations.d.ts.map

package/dist/core/extractors/runtime-registrations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-registrations.d.ts","sourceRoot":"","sources":["../../../src/core/extractors/runtime-registrations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAQ,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAC5E,OAAO,EAAkC,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AA2BtD;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,QAAQ,EAAE,iBAAiB,GAAG,MAAM,EACpC,OAAO,CAAC,EAAE,UAAU,EAAE,GACrB,mBAAmB,EAAE,CAKvB"}
+{"version":3,"file":"runtime-registrations.d.ts","sourceRoot":"","sources":["../../../src/core/extractors/runtime-registrations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,EAAQ,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAC5E,OAAO,EAAkC,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AA2BtD;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,QAAQ,EAAE,iBAAiB,GAAG,MAAM,EACpC,OAAO,CAAC,EAAE,UAAU,EAAE,GACrB,mBAAmB,EAAE,CAWvB"}