@assistant-ui/store 0.0.1 → 0.0.3

package/src/useAssistantState.tsx

@@ -1,41 +1,7 @@
-import { useMemo, useSyncExternalStore, useDebugValue } from "react";
-import type { AssistantClient, AssistantState } from "./types";
+import { useSyncExternalStore, useDebugValue } from "react";
+import type { AssistantState } from "./types/client";
 import { useAssistantClient } from "./useAssistantClient";
-
-/**
- * Proxied state that lazily accesses scope states
- */
-class ProxiedAssistantState {
-  #client: AssistantClient;
-
-  constructor(client: AssistantClient) {
-    this.#client = client;
-  }
-
-  #getScope<K extends keyof AssistantState>(key: K): AssistantState[K] {
-    const scopeField = this.#client[key];
-    if (!scopeField) {
-      throw new Error(`Scope "${String(key)}" not found in client`);
-    }
-
-    const api = scopeField();
-    const state = api.getState();
-    return state as AssistantState[K];
-  }
-
-  // Create a Proxy to dynamically handle property access
-  static create(client: AssistantClient): AssistantState {
-    const instance = new ProxiedAssistantState(client);
-    return new Proxy(instance, {
-      get(target, prop) {
-        if (typeof prop === "string" && prop in client) {
-          return target.#getScope(prop as keyof AssistantState);
-        }
-        return undefined;
-      },
-    }) as unknown as AssistantState;
-  }
-}
+import { getProxiedAssistantState } from "./utils/proxied-assistant-state";
 
 /**
  * Hook to access a slice of the assistant state with automatic subscription
@@ -45,7 +11,7 @@ class ProxiedAssistantState {
  *
  * @example
  * ```typescript
- * const client = useAssistantClient({
+ * const aui = useAssistantClient({
  *   foo: RootScope({ ... }),
  * });
  *
@@ -55,26 +21,22 @@ class ProxiedAssistantState {
 export const useAssistantState = <T,>(
   selector: (state: AssistantState) => T,
 ): T => {
-  const client = useAssistantClient();
-
-  const proxiedState = useMemo(
-    () => ProxiedAssistantState.create(client),
-    [client],
-  );
+  const aui = useAssistantClient();
+  const proxiedState = getProxiedAssistantState(aui);
 
   const slice = useSyncExternalStore(
-    client.subscribe,
+    aui.subscribe,
     () => selector(proxiedState),
     () => selector(proxiedState),
   );
 
-  useDebugValue(slice);
-
-  if (slice instanceof ProxiedAssistantState) {
+  if (slice === proxiedState) {
     throw new Error(
       "You tried to return the entire AssistantState. This is not supported due to technical limitations.",
     );
   }
 
+  useDebugValue(slice);
+
   return slice;
 };

package/src/utils/BaseProxyHandler.ts

@@ -0,0 +1,50 @@
+const INTROSPECTION_PROPS = new Set(["$$typeof", "nodeType", "then"]);
+
+/**
+ * Handles common proxy introspection properties.
+ * Returns the appropriate value for toStringTag, toJSON, and props that should return undefined.
+ * Returns `false` if the prop should be handled by the subclass.
+ */
+export const handleIntrospectionProp = (
+  prop: string | symbol,
+  name: string,
+): unknown | false => {
+  if (prop === Symbol.toStringTag) return name;
+  if (typeof prop === "symbol") return undefined;
+  if (prop === "toJSON") return () => name;
+  if (INTROSPECTION_PROPS.has(prop)) return undefined;
+  return false;
+};
+
+export abstract class BaseProxyHandler implements ProxyHandler<object> {
+  abstract get(_: unknown, prop: string | symbol): unknown;
+  abstract ownKeys(): ArrayLike<string | symbol>;
+  abstract has(_: unknown, prop: string | symbol): boolean;
+
+  getOwnPropertyDescriptor(_: unknown, prop: string | symbol) {
+    const value = this.get(_, prop);
+    if (value === undefined) return undefined;
+    return {
+      value,
+      writable: false,
+      enumerable: true,
+      configurable: false,
+    };
+  }
+
+  set() {
+    return false;
+  }
+  setPrototypeOf() {
+    return false;
+  }
+  defineProperty() {
+    return false;
+  }
+  deleteProperty() {
+    return false;
+  }
+  preventExtensions(): boolean {
+    return false;
+  }
+}

package/src/utils/NotificationManager.ts

@@ -0,0 +1,110 @@
+import { resource, tapMemo } from "@assistant-ui/tap";
+import type { ClientStack } from "./tap-client-stack-context";
+import type {
+  AssistantEventName,
+  AssistantEventPayload,
+} from "../types/events";
+import { Unsubscribe } from "../types/client";
+
+type InternalCallback = (payload: unknown, clientStack: ClientStack) => void;
+
+export type NotificationManager = {
+  on<TEvent extends AssistantEventName>(
+    event: TEvent,
+    callback: (
+      payload: AssistantEventPayload[TEvent],
+      clientStack: ClientStack,
+    ) => void,
+  ): Unsubscribe;
+  emit<TEvent extends Exclude<AssistantEventName, "*">>(
+    event: TEvent,
+    payload: AssistantEventPayload[TEvent],
+    clientStack: ClientStack,
+  ): void;
+  subscribe(callback: () => void): Unsubscribe;
+  notifySubscribers(): void;
+};
+
+export const NotificationManager = resource((): NotificationManager => {
+  return tapMemo(() => {
+    const listeners = new Map<string, Set<InternalCallback>>();
+    const wildcardListeners = new Set<InternalCallback>();
+    const subscribers = new Set<() => void>();
+
+    return {
+      on(event, callback) {
+        const cb = callback as InternalCallback;
+        if (event === "*") {
+          wildcardListeners.add(cb);
+          return () => wildcardListeners.delete(cb);
+        }
+
+        let set = listeners.get(event);
+        if (!set) {
+          set = new Set();
+          listeners.set(event, set);
+        }
+        set.add(cb);
+
+        return () => {
+          set!.delete(cb);
+          if (set!.size === 0) listeners.delete(event);
+        };
+      },
+
+      emit(event, payload, clientStack) {
+        const eventListeners = listeners.get(event);
+        if (!eventListeners && wildcardListeners.size === 0) return;
+
+        queueMicrotask(() => {
+          const errors = [];
+          if (eventListeners) {
+            for (const cb of eventListeners) {
+              try {
+                cb(payload, clientStack);
+              } catch (e) {
+                errors.push(e);
+              }
+            }
+          }
+          if (wildcardListeners.size > 0) {
+            const wrapped = { event, payload };
+            for (const cb of wildcardListeners) {
+              try {
+                cb(wrapped, clientStack);
+              } catch (e) {
+                errors.push(e);
+              }
+            }
+          }
+
+          if (errors.length > 0) {
+            if (errors.length === 1) {
+              throw errors[0];
+            } else {
+              throw new AggregateError(
+                errors,
+                "Errors occurred during event emission",
+              );
+            }
+          }
+        });
+      },
+
+      subscribe(callback) {
+        subscribers.add(callback);
+        return () => subscribers.delete(callback);
+      },
+
+      notifySubscribers() {
+        for (const cb of subscribers) {
+          try {
+            cb();
+          } catch (e) {
+            console.error("NotificationManager: subscriber callback error", e);
+          }
+        }
+      },
+    };
+  }, []);
+});

package/src/utils/StoreResource.ts

@@ -0,0 +1,36 @@
+import {
+  tapEffect,
+  ResourceElement,
+  resource,
+  createResource,
+  tapState,
+} from "@assistant-ui/tap";
+import { Unsubscribe } from "../types/client";
+
+export interface Store<TState> {
+  /**
+   * Get the current state of the store.
+   */
+  getState(): TState;
+
+  /**
+   * Subscribe to the store.
+   */
+  subscribe(listener: () => void): Unsubscribe;
+}
+
+export const StoreResource = resource(
+  <TState>(element: ResourceElement<TState>): Store<TState> => {
+    const [handle] = tapState(() => createResource(element, { mount: false }));
+
+    tapEffect(() => {
+      return handle.unmount;
+    }, [handle]);
+
+    tapEffect(() => {
+      handle.render(element);
+    }, [handle, element]);
+
+    return handle;
+  },
+);

package/src/utils/proxied-assistant-state.tsx

@@ -0,0 +1,53 @@
+"use client";
+import { getClientState } from "../tapClientResource";
+import type { AssistantClient, AssistantState } from "../types/client";
+import { BaseProxyHandler, handleIntrospectionProp } from "./BaseProxyHandler";
+
+export const PROXIED_ASSISTANT_STATE_SYMBOL = Symbol(
+  "assistant-ui.store.proxiedAssistantState",
+);
+
+const isIgnoredKey = (key: string | symbol): key is "on" | "subscribe" => {
+  return key === "on" || key === "subscribe" || typeof key === "symbol";
+};
+
+/**
+ * Proxied state that lazily accesses scope states
+ */
+export const createProxiedAssistantState = (
+  client: AssistantClient,
+): AssistantState => {
+  class ProxiedAssistantStateProxyHandler
+    extends BaseProxyHandler
+    implements ProxyHandler<AssistantState>
+  {
+    get(_: unknown, prop: string | symbol) {
+      const introspection = handleIntrospectionProp(prop, "AssistantState");
+      if (introspection !== false) return introspection;
+      const scope = prop as keyof AssistantClient;
+      if (isIgnoredKey(scope)) return undefined;
+      return getClientState(client[scope]());
+    }
+
+    ownKeys(): ArrayLike<string | symbol> {
+      return Object.keys(client).filter((key) => !isIgnoredKey(key));
+    }
+
+    has(_: unknown, prop: string | symbol): boolean {
+      return !isIgnoredKey(prop) && prop in client;
+    }
+  }
+
+  return new Proxy<AssistantState>(
+    {} as AssistantState,
+    new ProxiedAssistantStateProxyHandler(),
+  );
+};
+
+export const getProxiedAssistantState = (
+  client: AssistantClient,
+): AssistantState => {
+  return (
+    client as unknown as { [PROXIED_ASSISTANT_STATE_SYMBOL]: AssistantState }
+  )[PROXIED_ASSISTANT_STATE_SYMBOL];
+};

package/src/utils/react-assistant-context.tsx

@@ -0,0 +1,107 @@
+import React, { createContext, useContext } from "react";
+import type { AssistantClient, AssistantClientAccessor } from "../types/client";
+import {
+  createProxiedAssistantState,
+  PROXIED_ASSISTANT_STATE_SYMBOL,
+} from "./proxied-assistant-state";
+import { BaseProxyHandler, handleIntrospectionProp } from "./BaseProxyHandler";
+
+const NO_OP_SUBSCRIBE = () => () => {};
+
+const createErrorClientField = (
+  message: string,
+): AssistantClientAccessor<never> => {
+  const fn = (() => {
+    throw new Error(message);
+  }) as AssistantClientAccessor<never>;
+  fn.source = null;
+  fn.query = null;
+  return fn;
+};
+
+class DefaultAssistantClientProxyHandler
+  extends BaseProxyHandler
+  implements ProxyHandler<AssistantClient>
+{
+  get(_: unknown, prop: string | symbol) {
+    if (prop === "subscribe") return NO_OP_SUBSCRIBE;
+    if (prop === "on") return NO_OP_SUBSCRIBE;
+    if (prop === PROXIED_ASSISTANT_STATE_SYMBOL)
+      return DefaultAssistantClientProxiedAssistantState;
+    const introspection = handleIntrospectionProp(
+      prop,
+      "DefaultAssistantClient",
+    );
+    if (introspection !== false) return introspection;
+    return createErrorClientField(
+      `The current scope does not have a "${String(prop)}" property.`,
+    );
+  }
+
+  ownKeys(): ArrayLike<string | symbol> {
+    return ["subscribe", "on", PROXIED_ASSISTANT_STATE_SYMBOL];
+  }
+
+  has(_: unknown, prop: string | symbol): boolean {
+    return (
+      prop === "subscribe" ||
+      prop === "on" ||
+      prop === PROXIED_ASSISTANT_STATE_SYMBOL
+    );
+  }
+}
+/** Default context value - throws "wrap in AssistantProvider" error */
+export const DefaultAssistantClient: AssistantClient =
+  new Proxy<AssistantClient>(
+    {} as AssistantClient,
+    new DefaultAssistantClientProxyHandler(),
+  );
+
+const DefaultAssistantClientProxiedAssistantState = createProxiedAssistantState(
+  DefaultAssistantClient,
+);
+
+/** Root prototype for created clients - throws "scope not defined" error */
+export const createRootAssistantClient = (): AssistantClient =>
+  new Proxy<AssistantClient>({} as AssistantClient, {
+    get(_: AssistantClient, prop: string | symbol) {
+      const introspection = handleIntrospectionProp(prop, "AssistantClient");
+      if (introspection !== false) return introspection;
+      return createErrorClientField(
+        `The current scope does not have a "${String(prop)}" property.`,
+      );
+    },
+  });
+
+/**
+ * React Context for the AssistantClient
+ */
+const AssistantContext = createContext<AssistantClient>(DefaultAssistantClient);
+
+export const useAssistantContextValue = (): AssistantClient => {
+  return useContext(AssistantContext);
+};
+
+/**
+ * Provider component for AssistantClient
+ *
+ * @example
+ * ```typescript
+ * <AssistantProvider client={client}>
+ *   <YourApp />
+ * </AssistantProvider>
+ * ```
+ */
+export const AssistantProvider = ({
+  client,
+  children,
+}: {
+  client: AssistantClient;
+  children: React.ReactNode;
+}): React.ReactElement => {
+  return (
+    <AssistantContext.Provider value={client}>
+      {children}
+    </AssistantContext.Provider>
+  );
+};

package/src/utils/splitClients.ts

@@ -0,0 +1,85 @@
+import { Derived, DerivedElement } from "../Derived";
+import type {
+  AssistantClient,
+  ClientElement,
+  ClientNames,
+} from "../types/client";
+import { getDefaultPeers } from "../attachDefaultPeers";
+import type { useAssistantClient } from "../useAssistantClient";
+
+export type RootClients = Partial<
+  Record<ClientNames, ClientElement<ClientNames>>
+>;
+export type DerivedClients = Partial<
+  Record<ClientNames, DerivedElement<ClientNames>>
+>;
+
+/**
+ * Splits a clients object into root clients and derived clients.
+ *
+ * @param clients - The clients input object to split
+ * @returns An object with { rootClients, derivedClients }
+ *
+ * @example
+ * ```typescript
+ * const clients = {
+ *   foo: RootClient({ ... }),
+ *   bar: Derived({ ... }),
+ * };
+ *
+ * const { rootClients, derivedClients } = splitClients(clients);
+ * // rootClients = { foo: ... }
+ * // derivedClients = { bar: ... }
+ * ```
+ */
+export function splitClients(
+  clients: useAssistantClient.Props,
+  baseClient: AssistantClient,
+) {
+  const rootClients: RootClients = {};
+  const derivedClients: DerivedClients = {};
+
+  for (const [key, clientElement] of Object.entries(clients) as [
+    keyof useAssistantClient.Props,
+    NonNullable<useAssistantClient.Props[keyof useAssistantClient.Props]>,
+  ][]) {
+    if (clientElement.type === Derived) {
+      derivedClients[key] = clientElement as DerivedElement<ClientNames>;
+    } else {
+      rootClients[key] = clientElement as ClientElement<ClientNames>;
+    }
+  }
+
+  for (const [clientKey, clientElement] of Object.entries(rootClients) as [
+    ClientNames,
+    ClientElement<ClientNames>,
+  ][]) {
+    const defaultPeers = getDefaultPeers(clientElement.type);
+    if (!defaultPeers) continue;
+
+    for (const [key, peerElement] of Object.entries(defaultPeers) as [
+      ClientNames,
+      ClientElement<ClientNames> | DerivedElement<ClientNames>,
+    ][]) {
+      if (
+        key in rootClients ||
+        key in derivedClients ||
+        baseClient[key].source !== null
+      )
+        continue;
+
+      if (peerElement.type === Derived<ClientNames>) {
+        derivedClients[key] = peerElement as DerivedElement<ClientNames>;
+      } else {
+        rootClients[key] = peerElement as ClientElement<ClientNames>;
+        const subDefaultPeers = getDefaultPeers(peerElement.type);
+        if (subDefaultPeers)
+          throw new Error(
+            `Nested default peers are not supported. Client "${clientKey}" has default peers, but its peer "${key}" also has default peers.`,
+          );
+      }
+    }
+  }
+
+  return { rootClients, derivedClients };
+}

package/src/utils/tap-assistant-context.ts

@@ -0,0 +1,59 @@
+import {
+  createContext,
+  tapContext,
+  withContextProvider,
+  tapEffectEvent,
+} from "@assistant-ui/tap";
+import type {
+  AssistantEventName,
+  AssistantEventPayload,
+} from "../types/events";
+import type { AssistantClient } from "../types/client";
+import { tapClientStack, type ClientStack } from "./tap-client-stack-context";
+
+type EmitFn = <TEvent extends Exclude<AssistantEventName, "*">>(
+  event: TEvent,
+  payload: AssistantEventPayload[TEvent],
+  clientStack: ClientStack,
+) => void;
+
+export type AssistantTapContextValue = {
+  clientRef: { parent: AssistantClient; current: AssistantClient | null };
+  emit: EmitFn;
+};
+
+const AssistantTapContext = createContext<AssistantTapContextValue | null>(
+  null,
+);
+
+export const withAssistantTapContextProvider = <TResult>(
+  value: AssistantTapContextValue,
+  fn: () => TResult,
+) => {
+  return withContextProvider(AssistantTapContext, value, fn);
+};
+
+const tapAssistantTapContext = () => {
+  const ctx = tapContext(AssistantTapContext);
+  if (!ctx) throw new Error("AssistantTapContext is not available");
+
+  return ctx;
+};
+
+export const tapAssistantClientRef = () => {
+  return tapAssistantTapContext().clientRef;
+};
+
+export const tapAssistantEmit = () => {
+  const { emit } = tapAssistantTapContext();
+  const clientStack = tapClientStack();
+
+  return tapEffectEvent(
+    <TEvent extends Exclude<AssistantEventName, "*">>(
+      event: TEvent,
+      payload: AssistantEventPayload[TEvent],
+    ) => {
+      emit(event, payload, clientStack);
+    },
+  );
+};

package/src/utils/tap-client-stack-context.ts

@@ -0,0 +1,51 @@
+import {
+  createContext,
+  tapContext,
+  withContextProvider,
+  tapMemo,
+} from "@assistant-ui/tap";
+import type { ClientMethods } from "../types/client";
+
+/**
+ * Symbol used to get the client index from a ClientProxy.
+ */
+export const SYMBOL_CLIENT_INDEX = Symbol("assistant-ui.store.clientIndex");
+
+/**
+ * Get the index of a client (its position in the client stack when created).
+ */
+export const getClientIndex = (client: ClientMethods): number => {
+  return (client as unknown as { [SYMBOL_CLIENT_INDEX]: number })[
+    SYMBOL_CLIENT_INDEX
+  ];
+};
+
+/**
+ * The client stack - an array of clients representing the current hierarchy.
+ */
+export type ClientStack = readonly ClientMethods[];
+
+const ClientStackContext = createContext<ClientStack>([]);
+
+/**
+ * Get the current client stack inside a tap resource.
+ */
+export const tapClientStack = (): ClientStack => {
+  return tapContext(ClientStackContext);
+};
+
+/**
+ * Execute a callback with a client pushed onto the stack.
+ * The stack is duplicated, not mutated.
+ */
+export const tapWithClientStack = <T>(
+  client: ClientMethods,
+  callback: () => T,
+): T => {
+  const currentStack = tapClientStack();
+  const newStack = tapMemo(
+    () => [...currentStack, client],
+    [currentStack, client],
+  );
+  return withContextProvider(ClientStackContext, newStack, callback);
+};

package/dist/AssistantContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AssistantContext.d.ts","sourceRoot":"","sources":["../src/AssistantContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoC,MAAM,OAAO,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAA+B,MAAM,SAAS,CAAC;AAgB5E;;GAEG;AACH,eAAO,MAAM,gBAAgB,gCAe5B,CAAC;AAEF,eAAO,MAAM,wBAAwB,QAAO,eAE3C,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAAI,uBAG/B;IACD,MAAM,EAAE,eAAe,CAAC;IACxB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,KAAG,KAAK,CAAC,YAMT,CAAC"}

package/dist/AssistantContext.js

@@ -1,45 +0,0 @@
-// src/AssistantContext.tsx
-import { createContext, useContext } from "react";
-import { hasRegisteredScope } from "./ScopeRegistry.js";
-import { jsx } from "react/jsx-runtime";
-var NO_OP_SUBSCRIBE = () => () => {
-};
-var NO_OP_FLUSH_SYNC = () => {
-};
-var NO_OP_SCOPE_FIELD = (() => {
-  const fn = (() => {
-    throw new Error(
-      "You need to wrap this component/hook in <AssistantProvider>"
-    );
-  });
-  fn.source = null;
-  fn.query = null;
-  return fn;
-})();
-var AssistantContext = createContext(
-  new Proxy({}, {
-    get(_, prop) {
-      if (prop === "subscribe") return NO_OP_SUBSCRIBE;
-      if (prop === "on") return NO_OP_SUBSCRIBE;
-      if (prop === "flushSync") return NO_OP_FLUSH_SYNC;
-      if (hasRegisteredScope(prop))
-        return NO_OP_SCOPE_FIELD;
-      return null;
-    }
-  })
-);
-var useAssistantContextValue = () => {
-  return useContext(AssistantContext);
-};
-var AssistantProvider = ({
-  client,
-  children
-}) => {
-  return /* @__PURE__ */ jsx(AssistantContext.Provider, { value: client, children });
-};
-export {
-  AssistantContext,
-  AssistantProvider,
-  useAssistantContextValue
-};
-//# sourceMappingURL=AssistantContext.js.map

package/dist/AssistantContext.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/AssistantContext.tsx"],"sourcesContent":["import React, { createContext, useContext } from \"react\";\nimport type { AssistantClient, AssistantScopes, ScopeField } from \"./types\";\nimport { hasRegisteredScope } from \"./ScopeRegistry\";\n\nconst NO_OP_SUBSCRIBE = () => () => {};\nconst NO_OP_FLUSH_SYNC = () => {};\nconst NO_OP_SCOPE_FIELD = (() => {\n  const fn = (() => {\n    throw new Error(\n      \"You need to wrap this component/hook in <AssistantProvider>\",\n    );\n  }) as ScopeField<never>;\n  fn.source = null;\n  fn.query = null;\n  return fn;\n})();\n\n/**\n * React Context for the AssistantClient\n */\nexport const AssistantContext = createContext<AssistantClient>(\n  new Proxy({} as AssistantClient, {\n    get(_, prop: string) {\n      // Allow access to subscribe and flushSync without error\n      if (prop === \"subscribe\") return NO_OP_SUBSCRIBE;\n      if (prop === \"on\") return NO_OP_SUBSCRIBE;\n      if (prop === \"flushSync\") return NO_OP_FLUSH_SYNC;\n\n      // If this is a registered scope, return a function that errors when called or accessed\n      if (hasRegisteredScope(prop as keyof AssistantScopes))\n        return NO_OP_SCOPE_FIELD;\n\n      return null;\n    },\n  }),\n);\n\nexport const useAssistantContextValue = (): AssistantClient => {\n  return useContext(AssistantContext);\n};\n\n/**\n * Provider component for AssistantClient\n *\n * @example\n * ```typescript\n * <AssistantProvider client={client}>\n *   <YourApp />\n * </AssistantProvider>\n * ```\n */\nexport const AssistantProvider = ({\n  client,\n  children,\n}: {\n  client: AssistantClient;\n  children: React.ReactNode;\n}): React.ReactElement => {\n  return (\n    <AssistantContext.Provider value={client}>\n      {children}\n    </AssistantContext.Provider>\n  );\n};\n"],"mappings":";AAAA,SAAgB,eAAe,kBAAkB;AAEjD,SAAS,0BAA0B;AAyD/B;AAvDJ,IAAM,kBAAkB,MAAM,MAAM;AAAC;AACrC,IAAM,mBAAmB,MAAM;AAAC;AAChC,IAAM,qBAAqB,MAAM;AAC/B,QAAM,MAAM,MAAM;AAChB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,KAAG,SAAS;AACZ,KAAG,QAAQ;AACX,SAAO;AACT,GAAG;AAKI,IAAM,mBAAmB;AAAA,EAC9B,IAAI,MAAM,CAAC,GAAsB;AAAA,IAC/B,IAAI,GAAG,MAAc;AAEnB,UAAI,SAAS,YAAa,QAAO;AACjC,UAAI,SAAS,KAAM,QAAO;AAC1B,UAAI,SAAS,YAAa,QAAO;AAGjC,UAAI,mBAAmB,IAA6B;AAClD,eAAO;AAET,aAAO;AAAA,IACT;AAAA,EACF,CAAC;AACH;AAEO,IAAM,2BAA2B,MAAuB;AAC7D,SAAO,WAAW,gBAAgB;AACpC;AAYO,IAAM,oBAAoB,CAAC;AAAA,EAChC;AAAA,EACA;AACF,MAG0B;AACxB,SACE,oBAAC,iBAAiB,UAAjB,EAA0B,OAAO,QAC/B,UACH;AAEJ;","names":[]}