@arcadeai/design-system 3.26.1 → 3.27.1

package/dist/components/ui/organisms/toolkit-picker/hooks/use-toolkit-picker.js

@@ -1,323 +1,257 @@
-import { jsx as m } from "react/jsx-runtime";
-import { createContext as S, useReducer as E, useEffect as C, useContext as w } from "react";
-const r = (o, t) => t ? new Set(
-  o.filter((e) => e.searchableText?.toLowerCase().includes(t))
-) : new Set(o), d = (o, t) => {
-  if (!t)
+import { jsx as A } from "react/jsx-runtime";
+import { createContext as F, useReducer as b, useMemo as _, useEffect as g, useContext as v } from "react";
+const I = (e, o) => o ? new Set(
+  e.filter((t) => t.searchableText?.toLowerCase().includes(o))
+) : new Set(e), C = (e, o) => {
+  if (!o)
     return [];
-  const e = t.toolkitMap?.get(o);
-  if (!e?.tools?.length)
+  const t = o.toolkitMap?.get(e);
+  if (!t?.tools?.length)
     return [];
-  if (!t.tools?.length)
+  if (!o.tools?.length)
     return [];
-  const l = new Set(e.tools.map((i) => i.fully_qualified_name));
-  return t.tools.filter((i) => l.has(i.fully_qualified_name));
-}, _ = (o, t, e) => e ? e.toolkitMap?.get(t)?.tools?.some((i) => o.has(i.fully_qualified_name)) ?? !1 : !1, h = (o, t, e) => !t.size && e.size ? "tools" : t.size && !e.size ? "toolkits" : o, y = (o, t) => {
-  if (!t)
+  const s = new Set(t.tools.map((l) => l.fully_qualified_name));
+  return o.tools.filter((l) => s.has(l.fully_qualified_name));
+}, q = (e, o) => {
+  if (!o)
     return {
       selectedToolkits: /* @__PURE__ */ new Map(),
       selectedTools: /* @__PURE__ */ new Map()
     };
-  const e = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map();
-  if (o)
-    for (const i of o) {
-      l.set(i, !0);
-      const n = t.toolToToolkitMap?.get(i);
-      if (n) {
-        const s = t.toolkitMap?.get(n);
-        s && e.set(n, s);
+  const t = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+  if (e)
+    for (const l of e) {
+      s.set(l, !0);
+      const c = o.toolToToolkitMap?.get(l);
+      if (c) {
+        const i = o.toolkitMap?.get(c);
+        i && t.set(c, i);
       }
     }
   else
-    for (const i of t.toolkits) {
-      e.set(i.name, i);
-      for (const n of i.tools)
-        l.set(n.fully_qualified_name, !0);
+    for (const l of o.toolkits) {
+      t.set(l.name, l);
+      for (const c of l.tools)
+        s.set(c.fully_qualified_name, !0);
     }
-  return { selectedToolkits: e, selectedTools: l };
-}, p = (o, t, e) => {
-  if (!e)
-    return {
-      searchQuery: o,
-      activeTab: "toolkits",
-      filteredToolkits: /* @__PURE__ */ new Set(),
-      filteredTools: /* @__PURE__ */ new Set()
-    };
-  const l = t ? new Set(d(t, e)) : new Set(e.tools || []);
-  return {
-    searchQuery: o,
-    activeTab: "toolkits",
-    filteredToolkits: new Set(e.toolkits || []),
-    filteredTools: l
-  };
-}, L = (o, t) => {
-  const e = o.toLowerCase().trim(), { toolkits: l = [], tools: i = [] } = t.toolkitCollection || {}, n = !l.length, s = !i.length;
-  if (n && s)
-    return { searchQuery: o };
-  const c = r(l, e), u = t.toolkitFilter ? d(t.toolkitFilter, t.toolkitCollection) : i, a = r(u, e);
-  return {
-    searchQuery: o,
-    filteredToolkits: c,
-    filteredTools: a,
-    activeTab: h(t.activeTab, c, a)
-  };
-}, M = (o, t) => {
-  const e = t.selectedTools.has(o), l = t.toolkitCollection?.toolToToolkitMap?.get(o), i = new Map(t.selectedToolkits), n = new Map(t.selectedTools);
+  return { selectedToolkits: t, selectedTools: s };
+}, f = (e, o, t) => {
+  const s = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map();
+  if (!t)
+    return { selectedToolkits: s, selectedTools: l };
   if (e)
-    n.delete(o), l && (_(
-      n,
-      l,
-      t.toolkitCollection
-    ) || i.delete(l));
-  else if (t.selectionMode === "single" && (n.clear(), i.clear()), n.set(o, !0), l) {
-    const s = t.toolkitCollection?.toolkitMap?.get(l);
-    s && i.set(l, s);
-  }
-  return { selectedTools: n, selectedToolkits: i };
-}, k = (o, t, e) => {
-  const l = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
-  if (!e)
-    return { selectedToolkits: l, selectedTools: i };
-  if (o)
-    for (const n of o) {
-      const s = e.toolkitMap?.get(n);
-      s && l.set(n, s);
+    for (const c of e) {
+      const i = t.toolkitMap?.get(c);
+      i && s.set(c, i);
     }
-  if (t)
-    for (const n of t)
-      i.set(n, !0);
-  return { selectedToolkits: l, selectedTools: i };
-}, I = (o) => {
-  const { selectedToolkits: t, selectedTools: e } = k(
-    o.initialProps?.selectedToolkits,
-    o.initialProps?.selectedTools,
-    o.toolkitCollection
-  ), { selectedToolkits: l, selectedTools: i } = k(
-    o.initialProps?.committedToolkits || o.initialProps?.selectedToolkits,
-    o.initialProps?.committedTools || o.initialProps?.selectedTools,
-    o.toolkitCollection
+  if (o)
+    for (const c of o)
+      l.set(c, !0);
+  return { selectedToolkits: s, selectedTools: l };
+}, N = (e) => {
+  const { selectedToolkits: o, selectedTools: t } = f(
+    e.initialProps?.selectedToolkits,
+    e.initialProps?.selectedTools,
+    e.toolkitCollection
+  ), { selectedToolkits: s, selectedTools: l } = f(
+    e.initialProps?.committedToolkits || e.initialProps?.selectedToolkits,
+    e.initialProps?.committedTools || e.initialProps?.selectedTools,
+    e.toolkitCollection
   );
   return {
-    toolkitCollection: o.toolkitCollection,
-    selectionMode: o.selectionMode || "multi",
-    selectedToolkits: t,
-    selectedTools: e,
-    committedToolkits: l,
-    committedTools: i,
+    selectionMode: e.selectionMode || "multi",
+    selectedToolkits: o,
+    selectedTools: t,
+    committedToolkits: s,
+    committedTools: l,
     searchQuery: "",
     toolkitFilter: "",
-    activeTab: "toolkits",
-    filteredToolkits: new Set(o.toolkitCollection?.toolkits || []),
-    filteredTools: new Set(o.toolkitCollection?.tools || [])
+    activeTab: "toolkits"
   };
-}, O = (o, t) => {
-  switch (t.type) {
+}, P = (e, o) => {
+  switch (o.type) {
     case "TOGGLE_TOOLKIT": {
-      const e = t.payload, { name: l, tools: i } = e, n = o.selectedToolkits.has(l), s = new Map(o.selectedToolkits), T = new Map(o.selectedTools);
-      if (n) {
-        s.delete(l);
-        for (const c of i)
-          T.delete(c.fully_qualified_name);
+      const t = o.payload, { name: s, tools: l } = t, c = e.selectedToolkits.has(s), i = new Map(e.selectedToolkits), T = new Map(e.selectedTools);
+      if (c) {
+        i.delete(s);
+        for (const r of l)
+          T.delete(r.fully_qualified_name);
       } else {
-        s.set(l, e);
-        for (const c of i)
-          T.set(c.fully_qualified_name, !0);
+        i.set(s, t);
+        for (const r of l)
+          T.set(r.fully_qualified_name, !0);
       }
       return {
-        ...o,
-        selectedToolkits: s,
+        ...e,
+        selectedToolkits: i,
         selectedTools: T
       };
     }
     case "SET_INITIAL_SELECTIONS": {
-      const e = t.payload, { selectedToolkits: l, selectedTools: i } = k(
-        e.selectedToolkits,
-        e.selectedTools,
-        o.toolkitCollection
+      const t = o.payload, s = o.collection, { selectedToolkits: l, selectedTools: c } = f(
+        t.selectedToolkits,
+        t.selectedTools,
+        s
       ), {
-        selectedToolkits: n,
-        selectedTools: s
-      } = k(
-        e.committedToolkits || e.selectedToolkits,
-        e.committedTools || e.selectedTools,
-        o.toolkitCollection
+        selectedToolkits: i,
+        selectedTools: T
+      } = f(
+        t.committedToolkits || t.selectedToolkits,
+        t.committedTools || t.selectedTools,
+        s
       );
       return {
-        ...o,
+        ...e,
         selectedToolkits: l,
-        selectedTools: i,
-        committedToolkits: n,
-        committedTools: s
+        selectedTools: c,
+        committedToolkits: i,
+        committedTools: T
       };
     }
     case "TOGGLE_TOOL": {
-      const e = t.payload.fully_qualified_name, l = M(e, o);
-      return { ...o, ...l };
+      const { toolFqn: t, toolkitName: s, toolkit: l, selectionMode: c } = o.payload, i = e.selectedTools.has(t), T = new Map(e.selectedToolkits), r = new Map(e.selectedTools);
+      return i ? (r.delete(t), s && l && (l.tools?.some(
+        (d) => d.fully_qualified_name !== t && r.has(d.fully_qualified_name)
+      ) || T.delete(s))) : (c === "single" && (r.clear(), T.clear()), r.set(t, !0), s && l && T.set(s, l)), {
+        ...e,
+        selectedTools: r,
+        selectedToolkits: T
+      };
     }
     case "SELECT_ALL": {
-      const e = t.payload, l = e?.length === 0, n = !e && !o.toolkitCollection?.toolkits?.length;
-      if (l || n)
-        return o;
-      const s = y(e, o.toolkitCollection);
-      return { ...o, ...s };
+      const { visibleToolFqns: t, collection: s } = o.payload, l = t?.length === 0, i = !t && !s?.toolkits?.length;
+      if (l || i)
+        return e;
+      const T = q(t, s);
+      return { ...e, ...T };
     }
     case "CLEAR_SELECTIONS":
       return {
-        ...o,
+        ...e,
         selectedToolkits: /* @__PURE__ */ new Map(),
         selectedTools: /* @__PURE__ */ new Map()
       };
     case "COMMIT_SELECTIONS":
       return {
-        ...o,
-        committedToolkits: new Map(o.selectedToolkits),
-        committedTools: new Map(o.selectedTools)
+        ...e,
+        committedToolkits: new Map(e.selectedToolkits),
+        committedTools: new Map(e.selectedTools)
       };
     case "RESTORE_COMMITTED_STATE":
       return {
-        ...o,
-        selectedToolkits: new Map(o.committedToolkits),
-        selectedTools: new Map(o.committedTools)
+        ...e,
+        selectedToolkits: new Map(e.committedToolkits),
+        selectedTools: new Map(e.committedTools)
       };
-    case "SET_SEARCH_QUERY": {
-      const e = t.payload;
-      if (o.searchQuery === e)
-        return o;
-      if (!e.toLowerCase().trim()) {
-        const n = p(
-          e,
-          o.toolkitFilter,
-          o.toolkitCollection
-        );
-        return { ...o, ...n };
-      }
-      const i = L(e, o);
-      return { ...o, ...i };
-    }
-    case "CLEAR_SEARCH_QUERY": {
-      const e = o.toolkitFilter ? new Set(
-        d(o.toolkitFilter, o.toolkitCollection)
-      ) : new Set(o.toolkitCollection?.tools || []);
-      return {
-        ...o,
-        searchQuery: "",
-        activeTab: "toolkits",
-        filteredToolkits: new Set(o.toolkitCollection?.toolkits || []),
-        filteredTools: e
-      };
-    }
-    case "SET_TOOLKIT_FILTER": {
-      const e = t.payload, l = d(
-        e,
-        o.toolkitCollection
-      );
-      if (!l.length)
-        return { ...o, toolkitFilter: e };
-      const i = o.searchQuery.toLowerCase().trim();
-      return {
-        ...o,
-        toolkitFilter: e,
-        activeTab: "tools",
-        filteredTools: r(l, i)
-      };
-    }
-    case "CLEAR_FILTER": {
-      const e = o.searchQuery.toLowerCase().trim();
-      return e ? {
-        ...o,
-        toolkitFilter: "",
-        activeTab: "toolkits",
-        filteredToolkits: r(
-          o.toolkitCollection?.toolkits || [],
-          e
-        ),
-        filteredTools: r(
-          o.toolkitCollection?.tools || [],
-          e
-        )
-      } : {
-        ...o,
-        toolkitFilter: "",
-        activeTab: "toolkits",
-        filteredToolkits: new Set(o.toolkitCollection?.toolkits || []),
-        filteredTools: new Set(o.toolkitCollection?.tools || [])
-      };
-    }
+    case "SET_SEARCH_QUERY":
+      return { ...e, searchQuery: o.payload };
+    case "CLEAR_SEARCH_QUERY":
+      return { ...e, searchQuery: "", activeTab: "toolkits" };
+    case "SET_TOOLKIT_FILTER":
+      return { ...e, toolkitFilter: o.payload, activeTab: "tools" };
+    case "CLEAR_FILTER":
+      return { ...e, toolkitFilter: "", activeTab: "toolkits" };
     case "SET_ACTIVE_TAB": {
-      const e = t.payload;
-      if (e === "toolkits" && o.toolkitFilter) {
-        const l = o.searchQuery.toLowerCase().trim();
-        return l ? {
-          ...o,
-          activeTab: e,
-          toolkitFilter: "",
-          filteredToolkits: r(
-            o.toolkitCollection?.toolkits || [],
-            l
-          ),
-          filteredTools: r(
-            o.toolkitCollection?.tools || [],
-            l
-          )
-        } : {
-          ...o,
-          activeTab: e,
-          toolkitFilter: "",
-          filteredToolkits: new Set(o.toolkitCollection?.toolkits || []),
-          filteredTools: new Set(o.toolkitCollection?.tools || [])
-        };
-      }
-      return { ...o, activeTab: e };
+      const t = o.payload;
+      return t === "toolkits" && e.toolkitFilter ? { ...e, activeTab: t, toolkitFilter: "" } : { ...e, activeTab: t };
     }
     default:
-      return o;
+      return e;
   }
-}, f = S(
+}, O = F(
   null
 );
-function A({
-  children: o,
-  toolkitCollection: t,
-  selectionMode: e,
-  initialProps: l
+function G({
+  children: e,
+  toolkitCollection: o,
+  selectionMode: t,
+  initialProps: s
 }) {
-  const i = {
-    toolkitCollection: t,
-    selectionMode: e,
-    initialProps: l
-  }, [n, s] = E(
-    O,
-    i,
-    I
+  const l = {
+    toolkitCollection: o,
+    selectionMode: t,
+    initialProps: s
+  }, [c, i] = b(
+    P,
+    l,
+    N
+  ), { searchQuery: T, toolkitFilter: r, activeTab: k } = c, { filteredToolkits: d, filteredTools: p, effectiveTab: S } = _(() => {
+    const n = T.toLowerCase().trim(), u = o?.toolkits || [], a = r ? C(r, o) : [], m = r && a.length > 0 ? a : o?.tools || [], M = I(u, n), L = I(m, n);
+    let E = k;
+    if (n) {
+      const w = M.size > 0, h = L.size > 0;
+      !w && h ? E = "tools" : w && !h && (E = "toolkits");
+    }
+    return {
+      filteredToolkits: M,
+      filteredTools: L,
+      effectiveTab: E
+    };
+  }, [o, T, r, k]), y = _(
+    () => ({
+      ...c,
+      activeTab: S,
+      toolkitCollection: o,
+      filteredToolkits: d,
+      filteredTools: p
+    }),
+    [
+      c,
+      S,
+      o,
+      d,
+      p
+    ]
   );
-  C(() => {
-    t && l && (l.selectedToolkits || l.selectedTools || l.committedToolkits || l.committedTools) && s({ type: "SET_INITIAL_SELECTIONS", payload: l });
-  }, [t, l]);
-  const T = {
-    state: n,
-    toggleToolkit: (c) => s({ type: "TOGGLE_TOOLKIT", payload: c }),
-    toggleTool: (c) => s({ type: "TOGGLE_TOOL", payload: c }),
-    selectAll: (c) => s({ type: "SELECT_ALL", payload: c }),
-    clearSelections: () => s({ type: "CLEAR_SELECTIONS" }),
-    commitSelections: () => s({ type: "COMMIT_SELECTIONS" }),
-    restoreCommittedState: () => s({ type: "RESTORE_COMMITTED_STATE" }),
-    setSearchQuery: (c) => s({ type: "SET_SEARCH_QUERY", payload: c }),
-    clearSearchQuery: () => s({ type: "CLEAR_SEARCH_QUERY" }),
-    setToolkitFilter: (c) => s({ type: "SET_TOOLKIT_FILTER", payload: c }),
-    clearFilter: () => s({ type: "CLEAR_FILTER" }),
-    setActiveTab: (c) => s({ type: "SET_ACTIVE_TAB", payload: c })
-  };
-  return /* @__PURE__ */ m(f.Provider, { value: T, children: o });
+  g(() => {
+    o && s && (s.selectedToolkits || s.selectedTools || s.committedToolkits || s.committedTools) && i({
+      type: "SET_INITIAL_SELECTIONS",
+      payload: s,
+      collection: o
+    });
+  }, [o, s]);
+  const R = _(
+    () => ({
+      state: y,
+      toggleToolkit: (n) => i({ type: "TOGGLE_TOOLKIT", payload: n }),
+      toggleTool: (n) => {
+        const u = n.fully_qualified_name, a = o?.toolToToolkitMap?.get(u), m = a ? o?.toolkitMap?.get(a) : void 0;
+        i({
+          type: "TOGGLE_TOOL",
+          payload: {
+            toolFqn: u,
+            toolkitName: a,
+            toolkit: m,
+            selectionMode: c.selectionMode
+          }
+        });
+      },
+      selectAll: (n) => i({
+        type: "SELECT_ALL",
+        payload: { visibleToolFqns: n, collection: o }
+      }),
+      clearSelections: () => i({ type: "CLEAR_SELECTIONS" }),
+      commitSelections: () => i({ type: "COMMIT_SELECTIONS" }),
+      restoreCommittedState: () => i({ type: "RESTORE_COMMITTED_STATE" }),
+      setSearchQuery: (n) => i({ type: "SET_SEARCH_QUERY", payload: n }),
+      clearSearchQuery: () => i({ type: "CLEAR_SEARCH_QUERY" }),
+      setToolkitFilter: (n) => i({ type: "SET_TOOLKIT_FILTER", payload: n }),
+      clearFilter: () => i({ type: "CLEAR_FILTER" }),
+      setActiveTab: (n) => i({ type: "SET_ACTIVE_TAB", payload: n })
+    }),
+    [y, o, c.selectionMode]
+  );
+  return /* @__PURE__ */ A(O.Provider, { value: R, children: e });
 }
-function F() {
-  const o = w(f);
-  if (!o)
+function V() {
+  const e = v(O);
+  if (!e)
     throw new Error(
       "useToolkitPicker must be used within a ToolkitPickerProvider. Make sure to wrap your component with <ToolkitPickerProvider>."
     );
-  return o;
+  return e;
 }
 export {
-  A as ToolkitPickerProvider,
-  F as useToolkitPicker
+  G as ToolkitPickerProvider,
+  V as useToolkitPicker
 };

package/dist/components/ui/organisms/toolkit-picker/index.d.ts

@@ -1,7 +1,7 @@
 import { ToolkitCollection } from '../../../../lib/arcade/arcade';
 import { ToolkitPickerInitialProps } from './hooks/use-toolkit-picker';
-import type * as React from 'react';
-export type SelectionMode = 'multi' | 'single';
+import type * as React from "react";
+export type SelectionMode = "multi" | "single";
 export type ToolkitPickerProps = {
     onSelectionChange?: (args: {
         selectedToolkits: string[];
@@ -14,3 +14,4 @@ export type ToolkitPickerProps = {
     initialProps?: ToolkitPickerInitialProps;
 };
 export declare function ToolkitPicker(props: ToolkitPickerProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/components/ui/organisms/toolkit-picker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../lib/components/ui/organisms/toolkit-picker/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AACpC,OAAO,EACL,KAAK,yBAAyB,EAE/B,MAAM,4BAA4B,CAAC;AAGpC,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE/C,MAAM,MAAM,kBAAkB,GAAG;IAC/B,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE;QACzB,gBAAgB,EAAE,MAAM,EAAE,CAAC;QAC3B,aAAa,EAAE,MAAM,EAAE,CAAC;KACzB,KAAK,IAAI,CAAC;IACX,iBAAiB,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC;IAC7B,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,YAAY,CAAC,EAAE,yBAAyB,CAAC;CAC1C,CAAC;AAEF,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,2CAUtD"}

package/dist/components/ui/organisms/toolkit-picker/mocks/toolkit-collection.d.ts

@@ -6,4 +6,9 @@ export declare const mockToolkitCollection: ToolkitCollection;
 export declare const simpleMockToolkitCollection: ToolkitCollection;
 export declare const demoMockToolkits: Record<string, Toolkit>;
 export declare const demoMockToolkitCollection: ToolkitCollection;
-export declare function generateLargeDataset(): Record<string, Toolkit>;
+export declare function generateLargeDataset(options?: {
+    toolkitCount?: number;
+    minToolsPerToolkit?: number;
+    maxToolsPerToolkit?: number;
+}): Record<string, Toolkit>;
+//# sourceMappingURL=toolkit-collection.d.ts.map

package/dist/components/ui/organisms/toolkit-picker/mocks/toolkit-collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolkit-collection.d.ts","sourceRoot":"","sources":["../../../../../../lib/components/ui/organisms/toolkit-picker/mocks/toolkit-collection.ts"],"names":[],"mappings":"AAAA,OAAO,8BAA8B,CAAC;AAEtC,OAAO,KAAK,EAGV,OAAO,EACP,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AA2C/B,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAqPhD,CAAC;AAGF,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,iBAAiB,CA8HnB;AAGD,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAqDtD,CAAC;AAEF,eAAO,MAAM,qBAAqB,mBAA4C,CAAC;AAC/E,eAAO,MAAM,2BAA2B,mBACS,CAAC;AAGlD,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CA2LpD,CAAC;AAEF,eAAO,MAAM,yBAAyB,mBACS,CAAC;AAGhD,wBAAgB,oBAAoB,CAClC,OAAO,GAAE;IACP,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,kBAAkB,CAAC,EAAE,MAAM,CAAC;CACxB,GACL,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA2LzB"}