@frontmcp/ui 1.2.1 → 1.4.0

package/auth/index.js

@@ -0,0 +1,421 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/ui/src/auth/index.ts
+var auth_exports = {};
+__export(auth_exports, {
+  AUTH_EXTRA_FIELD: () => AUTH_EXTRA_FIELD,
+  AUTH_FLOW_GLOBAL_KEY: () => AUTH_FLOW_GLOBAL_KEY,
+  AUTH_WIRE_FIELDS: () => AUTH_WIRE_FIELDS,
+  AuthFlowContext: () => AuthFlowContext,
+  AuthFlowProvider: () => AuthFlowProvider,
+  AuthPageWrapper: () => AuthPageWrapper,
+  CONSENT_SUBMITTED_VALUE: () => CONSENT_SUBMITTED_VALUE,
+  DEFAULT_AUTH_MOUNT_ID: () => DEFAULT_AUTH_MOUNT_ID,
+  DEFAULT_SUBMIT_METHOD: () => DEFAULT_SUBMIT_METHOD,
+  WIRE_TRUE: () => WIRE_TRUE,
+  getAddedItems: () => getAddedItems,
+  getAuthFlow: () => getAuthFlow,
+  mountAuthPage: () => mountAuthPage,
+  setAuthNavigator: () => setAuthNavigator,
+  submitExtra: () => submitExtra,
+  submitFinish: () => submitFinish,
+  tryGetAuthFlow: () => tryGetAuthFlow,
+  useAddedItems: () => useAddedItems,
+  useAuthFlow: () => useAuthFlow,
+  useExtraField: () => useExtraField
+});
+module.exports = __toCommonJS(auth_exports);
+
+// libs/ui/src/auth/contract.ts
+var AUTH_FLOW_GLOBAL_KEY = "__FRONTMCP_AUTH__";
+var DEFAULT_SUBMIT_METHOD = "GET";
+var AUTH_WIRE_FIELDS = {
+  /** Pending authorization id. */
+  pendingAuthId: "pending_auth_id",
+  /** Anti-CSRF token. */
+  csrf: "csrf",
+  /** Marks a consent-form submission (distinguishes empty-select from first visit). */
+  consentSubmitted: "consent_submitted",
+  /** Repeated checkbox field carrying selected tool ids on the consent slot. */
+  tools: "tools",
+  /** Marks a federated submission. */
+  federated: "federated",
+  /** Repeated checkbox field carrying selected provider ids on the federated slot. */
+  providers: "providers",
+  /** Marks an incremental authorization. */
+  incremental: "incremental",
+  /** Target app id for incremental authorization. */
+  appId: "app_id",
+  /** Generic action discriminator (e.g. consent `authorize`/`skip`, or an extra name). */
+  action: "action"
+};
+var CONSENT_SUBMITTED_VALUE = "1";
+var WIRE_TRUE = "true";
+var AUTH_EXTRA_FIELD = AUTH_WIRE_FIELDS.action;
+var DEFAULT_AUTH_MOUNT_ID = "frontmcp-auth-root";
+
+// libs/ui/src/auth/vanilla/auth-flow.ts
+function getGlobalCarrier() {
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  return globalThis;
+}
+function getAuthFlow() {
+  const state = tryGetAuthFlow();
+  if (!state) {
+    throw new Error(
+      `[auth-ui] No injected auth flow state found on window.${AUTH_FLOW_GLOBAL_KEY}. This page must be server-rendered by a FrontMCP @AuthUi slot.`
+    );
+  }
+  return state;
+}
+function tryGetAuthFlow() {
+  const carrier = getGlobalCarrier();
+  const state = carrier?.[AUTH_FLOW_GLOBAL_KEY];
+  if (!state || typeof state !== "object") {
+    return void 0;
+  }
+  return state;
+}
+function getAddedItems(name) {
+  const items = tryGetAuthFlow()?.addedItems?.[name];
+  return Array.isArray(items) ? items : [];
+}
+function toEntries(input) {
+  if (!input) {
+    return [];
+  }
+  if (isFormElement(input)) {
+    return formDataToEntries(new FormData(input));
+  }
+  if (typeof FormData !== "undefined" && input instanceof FormData) {
+    return formDataToEntries(input);
+  }
+  const entries = [];
+  for (const [key, value] of Object.entries(input)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        if (v !== void 0 && v !== null) {
+          entries.push([key, String(v)]);
+        }
+      }
+    } else {
+      entries.push([key, String(value)]);
+    }
+  }
+  return entries;
+}
+function formDataToEntries(fd) {
+  const entries = [];
+  fd.forEach((value, key) => {
+    if (typeof value === "string") {
+      entries.push([key, value]);
+    }
+  });
+  return entries;
+}
+function isFormElement(input) {
+  return typeof input === "object" && // `nodeName` + a `FormData`-constructible shape is enough; avoids requiring
+  // a live `HTMLFormElement` global (jsdom provides one, node does not).
+  input.nodeName === "FORM";
+}
+function buildGetUrl(base, entries) {
+  const origin = typeof window !== "undefined" && window.location ? window.location.origin : void 0;
+  const url = origin ? new URL(base, origin) : new URL(base, "http://localhost");
+  for (const [key, value] of entries) {
+    url.searchParams.append(key, value);
+  }
+  if (!origin && !/^https?:\/\//i.test(base)) {
+    return `${url.pathname}${url.search}`;
+  }
+  return url.toString();
+}
+function buildUrlEncodedBody(entries) {
+  const params = new URLSearchParams();
+  for (const [key, value] of entries) {
+    params.append(key, value);
+  }
+  return params.toString();
+}
+function withControlFields(state, entries, markers) {
+  const present = new Set(entries.map(([k]) => k));
+  const merged = [...entries];
+  const ensure = (key, value) => {
+    if (value !== void 0 && !present.has(key)) {
+      merged.push([key, value]);
+      present.add(key);
+    }
+  };
+  ensure(AUTH_WIRE_FIELDS.pendingAuthId, state.pendingAuthId);
+  ensure(AUTH_WIRE_FIELDS.csrf, state.csrfToken);
+  for (const [key, value] of markers) {
+    ensure(key, value);
+  }
+  return merged;
+}
+function finishMarkers(state) {
+  switch (state.slot) {
+    case "consent":
+      return [[AUTH_WIRE_FIELDS.consentSubmitted, CONSENT_SUBMITTED_VALUE]];
+    default:
+      return [];
+  }
+}
+async function dispatch(method, url, entries) {
+  if (typeof fetch !== "function") {
+    throw new Error("[auth-ui] global fetch is unavailable in this environment");
+  }
+  if (method === "GET") {
+    return fetch(buildGetUrl(url, entries), {
+      method: "GET",
+      credentials: "same-origin",
+      headers: { Accept: "application/json, text/html" }
+    });
+  }
+  return fetch(url, {
+    method: "POST",
+    credentials: "same-origin",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json, text/html"
+    },
+    body: buildUrlEncodedBody(entries)
+  });
+}
+var defaultNavigator = (url) => {
+  if (typeof window !== "undefined" && window.location) {
+    window.location.assign(url);
+  }
+};
+var currentNavigator = defaultNavigator;
+function setAuthNavigator(navigator) {
+  currentNavigator = navigator ?? defaultNavigator;
+}
+async function submitFinish(formOrData, options = {}) {
+  const state = options.state ?? getAuthFlow();
+  if (!state.submitUrl) {
+    throw new Error("[auth-ui] submitFinish called but the injected flow state has no submitUrl");
+  }
+  const method = state.submitMethod ?? DEFAULT_SUBMIT_METHOD;
+  const entries = withControlFields(state, toEntries(formOrData), finishMarkers(state));
+  const response = await dispatch(method, state.submitUrl, entries);
+  const shouldNavigate = options.navigate ?? (typeof window !== "undefined" && !!window.location);
+  if (shouldNavigate && response.redirected && response.url) {
+    currentNavigator(response.url);
+  }
+  return response;
+}
+async function submitExtra(name, data, state) {
+  const flow = state ?? getAuthFlow();
+  const target = flow.extraUrl ?? flow.submitUrl;
+  if (!target) {
+    throw new Error("[auth-ui] submitExtra called but the injected flow state has no extraUrl/submitUrl");
+  }
+  const markers = flow.extraUrl ? [] : [[AUTH_EXTRA_FIELD, name]];
+  const entries = withControlFields(flow, toEntries(data), markers);
+  const response = await dispatch("POST", target, entries);
+  return parseExtraResponse(response);
+}
+async function parseExtraResponse(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    try {
+      const body = await response.json();
+      return {
+        ok: body.ok ?? response.ok,
+        error: typeof body.error === "string" ? body.error : void 0,
+        addedItems: body.addedItems && typeof body.addedItems === "object" ? body.addedItems : void 0,
+        sideEffects: body.sideEffects && typeof body.sideEffects === "object" ? body.sideEffects : void 0
+      };
+    } catch {
+    }
+  }
+  if (response.ok) {
+    return { ok: true };
+  }
+  return { ok: false, error: `Request failed with status ${response.status}` };
+}
+
+// libs/ui/src/auth/context.tsx
+var import_react = require("react");
+var AuthFlowContext = (0, import_react.createContext)(null);
+function useAuthFlowContext() {
+  const ctx = (0, import_react.useContext)(AuthFlowContext);
+  if (!ctx) {
+    throw new Error("[auth-ui] useAuthFlow* hooks must be used inside <AuthPageWrapper> / <AuthFlowProvider>");
+  }
+  return ctx;
+}
+
+// libs/ui/src/auth/AuthPageWrapper.tsx
+var import_react2 = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+function AuthFlowProvider({
+  children,
+  state: stateOverride
+}) {
+  const injected = stateOverride ?? tryGetAuthFlow();
+  const [state, setState] = (0, import_react2.useState)(
+    injected ?? { slot: "error", error: "No authorization flow state was provided." }
+  );
+  const value = (0, import_react2.useMemo)(
+    () => ({
+      state,
+      update: (patch) => setState((prev) => ({ ...prev, ...patch }))
+    }),
+    [state]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AuthFlowContext.Provider, { value, children });
+}
+function ControlFields({ state }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+    state.pendingAuthId !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("input", { type: "hidden", name: AUTH_WIRE_FIELDS.pendingAuthId, value: state.pendingAuthId }),
+    state.csrfToken !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("input", { type: "hidden", name: AUTH_WIRE_FIELDS.csrf, value: state.csrfToken }),
+    state.slot === "consent" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("input", { type: "hidden", name: AUTH_WIRE_FIELDS.consentSubmitted, value: CONSENT_SUBMITTED_VALUE })
+  ] });
+}
+function AuthPageWrapper({
+  children,
+  state: stateOverride,
+  renderForm = true,
+  className
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AuthFlowProvider, { state: stateOverride, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AuthPageWrapperInner, { renderForm, className, children }) });
+}
+function AuthPageWrapperInner({
+  children,
+  renderForm,
+  className
+}) {
+  const ctx = useAuthFlowContextSafe();
+  const state = ctx?.state;
+  if (!renderForm || !state?.submitUrl) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: className ?? "frontmcp-auth-page", children });
+  }
+  const method = (state.submitMethod ?? DEFAULT_SUBMIT_METHOD).toLowerCase();
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: className ?? "frontmcp-auth-page", children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("form", { action: state.submitUrl, method, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ControlFields, { state }),
+    children
+  ] }) });
+}
+function useAuthFlowContextSafe() {
+  return (0, import_react2.useContext)(AuthFlowContext);
+}
+
+// libs/ui/src/auth/hooks.ts
+var import_react3 = require("react");
+function normalizeFormArg(arg) {
+  if (!arg) {
+    return void 0;
+  }
+  const maybeEvent = arg;
+  if (typeof maybeEvent.preventDefault === "function" && maybeEvent.currentTarget) {
+    maybeEvent.preventDefault();
+    return maybeEvent.currentTarget;
+  }
+  return arg;
+}
+function useAuthFlow() {
+  const { state } = useAuthFlowContext();
+  const submitFinish2 = (0, import_react3.useCallback)(
+    (formOrEvent) => submitFinish(normalizeFormArg(formOrEvent), { state }),
+    [state]
+  );
+  return {
+    slot: state.slot,
+    pendingAuthId: state.pendingAuthId,
+    clientName: state.clientName,
+    clientId: state.clientId,
+    scopes: state.scopes ?? [],
+    redirectUri: state.redirectUri,
+    resource: state.resource,
+    error: state.error,
+    providers: state.providers ?? [],
+    tools: state.tools ?? [],
+    extras: state.extras ?? {},
+    state,
+    submitFinish: submitFinish2
+  };
+}
+function useAddedItems(name) {
+  const { state } = useAuthFlowContext();
+  const items = state.addedItems?.[name];
+  return Array.isArray(items) ? items : [];
+}
+function useExtraField(name) {
+  const { state, update } = useAuthFlowContext();
+  const [result, setResult] = (0, import_react3.useState)(void 0);
+  const [pending, setPending] = (0, import_react3.useState)(false);
+  const onSubmit = (0, import_react3.useCallback)(
+    async (formOrEvent) => {
+      const data = normalizeFormArg(formOrEvent);
+      setPending(true);
+      try {
+        const res = await submitExtra(name, data, state);
+        setResult(res);
+        if (res.ok && res.addedItems) {
+          update({ addedItems: res.addedItems });
+        }
+        return res;
+      } catch (err) {
+        const failure = {
+          ok: false,
+          error: err instanceof Error ? err.message : "Failed to submit field"
+        };
+        setResult(failure);
+        return failure;
+      } finally {
+        setPending(false);
+      }
+    },
+    [name, state, update]
+  );
+  return { onSubmit, result, pending };
+}
+
+// libs/ui/src/auth/hydrate.tsx
+var import_client = require("react-dom/client");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function resolveContainer(container) {
+  if (container && typeof container !== "string") {
+    return container;
+  }
+  if (typeof document === "undefined") {
+    throw new Error("[auth-ui] mountAuthPage requires a DOM (document is undefined)");
+  }
+  const selector = container ?? `#${DEFAULT_AUTH_MOUNT_ID}`;
+  const el = document.querySelector(selector);
+  if (!el) {
+    throw new Error(`[auth-ui] mountAuthPage could not find a container matching "${selector}"`);
+  }
+  return el;
+}
+function mountAuthPage(Component, options = {}) {
+  const container = resolveContainer(options.container);
+  const root = (0, import_client.createRoot)(container);
+  root.render(
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AuthPageWrapper, { state: options.state, renderForm: options.renderForm, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Component, {}) })
+  );
+  return root;
+}

package/auth/vanilla/auth-flow.d.ts

@@ -0,0 +1,96 @@
+/**
+ * `@frontmcp/ui/auth/vanilla` — framework-free helpers that read the injected
+ * {@link AuthFlowState} global and drive the OAuth flow. No React.
+ *
+ * These are browser-DOM (client-only) primitives the `/auth` React hooks are
+ * built on, and are usable directly from a non-React (or no-framework)
+ * authorization page. The framework-free CONTRACT they consume is co-located in
+ * `@frontmcp/ui/auth` (`./contract`); these helpers touch
+ * `window`/`fetch`/`FormData`, so they are browser-only.
+ *
+ * @packageDocumentation
+ */
+import { type AuthExtraResult, type AuthFlowState, type AuthFormInput } from '../contract';
+/**
+ * Read the server-injected {@link AuthFlowState}.
+ *
+ * @throws Error when no flow state has been injected (the page was not rendered
+ * by a FrontMCP auth slot, or the injection script did not run yet). Callers
+ * that want a tolerant read should use {@link tryGetAuthFlow}.
+ */
+export declare function getAuthFlow(): AuthFlowState;
+/**
+ * Read the server-injected {@link AuthFlowState}, or `undefined` when it is not
+ * present. Does not throw — useful for optional/SSR-safe reads.
+ */
+export declare function tryGetAuthFlow(): AuthFlowState | undefined;
+/**
+ * Return the server-side accumulator for a named multi-step input (e.g. the
+ * `envs` a user has added so far). Empty array when the name is absent.
+ */
+export declare function getAddedItems<T = unknown>(name: string): T[];
+/**
+ * Options for {@link submitFinish}.
+ */
+export interface SubmitFinishOptions {
+    /**
+     * When true (the default in a real browser), a non-redirected/non-JSON HTML
+     * response causes a full navigation to `response.url` (the OAuth code
+     * redirect). Set false to suppress navigation and inspect the {@link Response}
+     * yourself (used by tests and SPA-style pages).
+     */
+    navigate?: boolean;
+    /**
+     * Drive the submit from this explicit flow state instead of reading the
+     * injected `window.__FRONTMCP_AUTH__`. Used by the React hooks (which already
+     * hold the state via context); standalone callers omit it.
+     */
+    state?: AuthFlowState;
+}
+/**
+ * How {@link submitFinish} performs a top-level navigation to the OAuth
+ * redirect. Defaults to `window.location.assign`. Exposed so SPA-style pages
+ * (and tests) can override it via {@link setAuthNavigator} without fighting a
+ * non-configurable `window.location`.
+ */
+export type AuthNavigator = (url: string) => void;
+/**
+ * Override the navigation function used to follow the OAuth redirect after a
+ * successful {@link submitFinish}. Pass no argument to reset to the default
+ * (`window.location.assign`).
+ */
+export declare function setAuthNavigator(navigator?: AuthNavigator): void;
+/**
+ * Finish the authorization flow: submit identity / selection back to the
+ * server's callback (`submitUrl`), carrying `pending_auth_id`, `csrf`, and the
+ * slot's marker fields (e.g. `consent_submitted=1` for consent).
+ *
+ * On success the server responds with the OAuth redirect to the client's
+ * `redirect_uri`; in a browser this helper follows it via a full navigation
+ * unless {@link SubmitFinishOptions.navigate} is false.
+ *
+ * @param formOrData The developer's form/fields (identity inputs, selected
+ * `tools`/`providers` checkboxes, etc.).
+ * @param options Submit options. `options.state` lets a caller (e.g. the React
+ * hooks) drive the submit from an explicit flow state instead of re-reading the
+ * injected global; when omitted the injected `window.__FRONTMCP_AUTH__` is used.
+ * @returns The raw {@link Response} (so callers can branch on a re-rendered
+ * error page vs. a redirect).
+ */
+export declare function submitFinish(formOrData?: AuthFormInput, options?: SubmitFinishOptions): Promise<Response>;
+/**
+ * Submit a single validated extra field (a `@AuthExtra(name)` round-trip).
+ *
+ * Posts the field data plus `pending_auth_id` + `csrf` to `extraUrl` when the
+ * server provided one, otherwise to `submitUrl` with an `action=<name>` field
+ * so the server can route it. Always uses POST (extras mutate server state —
+ * unlike the GET finish round-trip).
+ *
+ * @param name The extra's name (must match the server's `@AuthExtra(name)`).
+ * @param data The field value(s) to validate/add.
+ * @param state Optional explicit flow state (the React hooks pass their context
+ * state); when omitted the injected `window.__FRONTMCP_AUTH__` is used.
+ * @returns A parsed {@link AuthExtraResult} (`{ ok, error?, addedItems? }`).
+ */
+export declare function submitExtra(name: string, data?: AuthFormInput, state?: AuthFlowState): Promise<AuthExtraResult>;
+//# sourceMappingURL=auth-flow.d.ts.map

package/auth/vanilla/auth-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-flow.d.ts","sourceRoot":"","sources":["../../../src/auth/vanilla/auth-flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAML,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,aAAa,EAEnB,MAAM,aAAa,CAAC;AAgBrB;;;;;;GAMG;AACH,wBAAgB,WAAW,IAAI,aAAa,CAS3C;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,aAAa,GAAG,SAAS,CAO1D;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,EAAE,CAG5D;AAwJD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;AAUlD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,CAAC,EAAE,aAAa,GAAG,IAAI,CAEhE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,YAAY,CAAC,UAAU,CAAC,EAAE,aAAa,EAAE,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAenH;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,eAAe,CAAC,CAarH"}

package/auth/vanilla/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `@frontmcp/ui/auth/vanilla` — framework-free (browser-DOM) flow helpers + the
+ * contract.
+ *
+ * Re-exports the contract (the single source of truth lives in
+ * `@frontmcp/ui/auth`) so a non-React page can
+ * `import { getAuthFlow, type AuthFlowState } from '@frontmcp/ui/auth/vanilla'`
+ * from a single entrypoint.
+ *
+ * @packageDocumentation
+ */
+export * from '../contract';
+export * from './auth-flow';
+//# sourceMappingURL=index.d.ts.map

package/auth/vanilla/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/auth/vanilla/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC"}