@real-router/core 0.54.6 → 0.56.0

package/src/internals.ts

@@ -15,6 +15,7 @@ import type {
   RouteTreeState,
   SimpleState,
   State,
+  TreeChangedEvent,
   Unsubscribe,
 } from "@real-router/types";
 import type { RouteTree } from "route-tree";
@@ -51,6 +52,21 @@ export interface RouterInternals<
     cb: Plugin[EventMethodMap[E]],
   ) => Unsubscribe;
 
+  /**
+   * Route-tree mutation channel — internal access for the `getRoutesApi`
+   * wrapper. A dedicated bridge is required because the public
+   * `addEventListener<E extends EventName>` structurally rejects
+   * `"TREE_CHANGED"` (it is not in the public `EventName` union), is strict on
+   * duplicates, and exposes neither `emit` nor `listenerCount`.
+   */
+  readonly treeChanged: {
+    readonly emit: (event: TreeChangedEvent) => void;
+    readonly subscribe: (
+      handler: (event: TreeChangedEvent) => void,
+    ) => Unsubscribe;
+    readonly listenerCount: () => number;
+  };
+
   readonly buildPath: (route: string, params?: Params) => string;
 
   readonly emitTransitionError: (error: Error) => void;
@@ -160,6 +176,12 @@ function executeInterceptorChain<T>(
   return chain(...args) as T;
 }
 
+/**
+ * Variadic interceptor wrapper — wraps a function of any arity, returning the
+ * same callable type `T`. Use {@link createBinaryInterceptable} instead when the
+ * wrapped method takes exactly two args and the caller needs the precise
+ * `(a, b) => r` signature preserved (the variadic form widens args to `any[]`).
+ */
 export function createInterceptable<T extends (...args: any[]) => any>(
   name: string,
   original: T,
@@ -179,7 +201,13 @@ export function createInterceptable<T extends (...args: any[]) => any>(
   }) as T;
 }
 
-export function createInterceptable2<A, B, R>(
+/**
+ * Two-argument interceptor wrapper — preserves the exact `(a: A, b: B) => R`
+ * signature, which the variadic {@link createInterceptable} cannot express
+ * (it widens args to `any[]`). Used for the binary interceptable methods
+ * `forwardState(routeName, routeParams)` and `buildPath(route, params)`.
+ */
+export function createBinaryInterceptable<A, B, R>(
   name: string,
   original: (a: A, b: B) => R,
   interceptors: Map<

package/src/namespaces/EventBusNamespace/EventBusNamespace.ts

@@ -16,10 +16,19 @@ import type {
   Plugin,
   State,
   SubscribeFn,
+  TreeChangedEvent,
   Unsubscribe,
 } from "@real-router/types";
 import type { EventEmitter } from "event-emitter";
 
+/**
+ * Internal-only event key for route-tree mutations. Lives on the same
+ * `EventEmitter` as the 7 transition events but never enters the public
+ * `EventName` union — reachable only through
+ * `getRoutesApi(router).subscribeChanges()`.
+ */
+const TREE_CHANGED = "TREE_CHANGED";
+
 function ensureError(value: unknown): Error {
   /* v8 ignore next -- @preserve: defensive guard — listeners should always throw Error objects */
   return value instanceof Error ? value : new Error(String(value));
@@ -141,6 +150,34 @@ export class EventBusNamespace {
     this.#emitter.emit(events.TRANSITION_LEAVE_APPROVE, toState, fromState);
   }
 
+  /**
+   * Emits the internal `TREE_CHANGED` event after a structural route-tree
+   * mutation. Reuses the shared `EventEmitter` — so depth tracking
+   * (`maxEventDepth`) and per-listener error isolation (`onListenerError`)
+   * apply automatically.
+   */
+  emitTreeChanged(event: TreeChangedEvent): void {
+    this.#emitter.emit(TREE_CHANGED, event);
+  }
+
+  /**
+   * Subscribes to `TREE_CHANGED`. **Lenient** duplicate semantics (mirrors
+   * {@link subscribe}): each call wraps the handler in a fresh closure, so N
+   * registrations of the same reference produce N independent subscriptions.
+   */
+  subscribeTreeChanged(
+    handler: (event: TreeChangedEvent) => void,
+  ): Unsubscribe {
+    return this.#emitter.on(TREE_CHANGED, (event: TreeChangedEvent) => {
+      handler(event);
+    });
+  }
+
+  /** Number of active `TREE_CHANGED` listeners (drives conditional emit). */
+  treeChangedListenerCount(): number {
+    return this.#emitter.listenerCount(TREE_CHANGED);
+  }
+
   sendStart(): void {
     this.#fsm.send(routerEvents.START);
   }

package/src/namespaces/NavigationNamespace/types.ts

@@ -23,7 +23,7 @@ export interface NavigationContext {
  *
  * These are function references from other namespaces/facade,
  * avoiding the need to pass the entire Router object.
- **/
+ */
 export interface NavigationDependencies {
   /** Get router options */
   getOptions: () => Options;

package/src/namespaces/RoutesNamespace/routesStore.ts

@@ -132,6 +132,32 @@ export function refreshForwardMap(config: RouteConfig): Record<string, string> {
 // Route handler registration
 // =============================================================================
 
+/**
+ * Throws if `forwardTo` is an async function (native or transpiled). Async
+ * forwardTo callbacks break the synchronous matchPath/buildPath contract.
+ * Runs inside `registerForwardTo`, which the prepare-phase build invokes via
+ * `registerAllRouteHandlers` — so the check fires before any store mutation.
+ */
+function assertForwardToNotAsync(forwardTo: unknown, fullName: string): void {
+  if (typeof forwardTo !== "function") {
+    return;
+  }
+
+  const isNativeAsync =
+    (forwardTo as { constructor: { name: string } }).constructor.name ===
+    "AsyncFunction";
+  const isTranspiledAsync = (forwardTo as { toString: () => string })
+    .toString()
+    .includes("__awaiter");
+
+  if (isNativeAsync || isTranspiledAsync) {
+    throw new TypeError(
+      `forwardTo callback cannot be async for route "${fullName}". ` +
+        `Async functions break matchPath/buildPath.`,
+    );
+  }
+}
+
 function registerForwardTo<Dependencies extends DefaultDependencies>(
   route: Route<Dependencies>,
   fullName: string,
@@ -163,19 +189,7 @@ function registerForwardTo<Dependencies extends DefaultDependencies>(
     );
   }
 
-  if (typeof route.forwardTo === "function") {
-    const isNativeAsync =
-      (route.forwardTo as { constructor: { name: string } }).constructor
-        .name === "AsyncFunction";
-    const isTranspiledAsync = route.forwardTo.toString().includes("__awaiter");
-
-    if (isNativeAsync || isTranspiledAsync) {
-      throw new TypeError(
-        `forwardTo callback cannot be async for route "${fullName}". ` +
-          `Async functions break matchPath/buildPath.`,
-      );
-    }
-  }
+  assertForwardToNotAsync(route.forwardTo, fullName);
 
   // forwardTo is guaranteed to exist at this point
   if (typeof route.forwardTo === "string") {
@@ -193,7 +207,6 @@ function registerSingleRouteHandlers<Dependencies extends DefaultDependencies>(
   routeCustomFields: Record<string, Record<string, unknown>>,
   pendingCanActivate: Map<string, GuardFnFactory<Dependencies>>,
   pendingCanDeactivate: Map<string, GuardFnFactory<Dependencies>>,
-  depsStore: RoutesDependencies<Dependencies> | undefined,
 ): void {
   const standardKeys = new Set([
     "name",
@@ -214,20 +227,15 @@ function registerSingleRouteHandlers<Dependencies extends DefaultDependencies>(
     routeCustomFields[fullName] = customFields;
   }
 
+  // Guards are collected here and registered into the lifecycle later — by
+  // `adoptRouteArtifacts` (add/replace) or `setDependencies` (initial routes) —
+  // so the build stays a pure, side-effect-free preparation step.
   if (route.canActivate) {
-    if (depsStore) {
-      depsStore.addActivateGuard(fullName, route.canActivate);
-    } else {
-      pendingCanActivate.set(fullName, route.canActivate);
-    }
+    pendingCanActivate.set(fullName, route.canActivate);
   }
 
   if (route.canDeactivate) {
-    if (depsStore) {
-      depsStore.addDeactivateGuard(fullName, route.canDeactivate);
-    } else {
-      pendingCanDeactivate.set(fullName, route.canDeactivate);
-    }
+    pendingCanDeactivate.set(fullName, route.canDeactivate);
   }
 
   if (route.forwardTo) {
@@ -249,15 +257,12 @@ function registerSingleRouteHandlers<Dependencies extends DefaultDependencies>(
   }
 }
 
-export function registerAllRouteHandlers<
-  Dependencies extends DefaultDependencies,
->(
+function registerAllRouteHandlers<Dependencies extends DefaultDependencies>(
   routes: readonly Route<Dependencies>[],
   config: RouteConfig,
   routeCustomFields: Record<string, Record<string, unknown>>,
   pendingCanActivate: Map<string, GuardFnFactory<Dependencies>>,
   pendingCanDeactivate: Map<string, GuardFnFactory<Dependencies>>,
-  depsStore: RoutesDependencies<Dependencies> | undefined,
   parentName = "",
 ): void {
   for (const route of routes) {
@@ -270,7 +275,6 @@ export function registerAllRouteHandlers<
       routeCustomFields,
       pendingCanActivate,
       pendingCanDeactivate,
-      depsStore,
     );
 
     if (route.children) {
@@ -280,7 +284,6 @@ export function registerAllRouteHandlers<
         routeCustomFields,
         pendingCanActivate,
         pendingCanDeactivate,
-        depsStore,
         fullName,
       );
     }
@@ -288,55 +291,272 @@ export function registerAllRouteHandlers<
 }
 
 // =============================================================================
-// Factory
+// Prepare-then-commit (issue #698)
+//
+// add()/replace() build the complete new store state into LOCAL structures, and
+// only swap it into the store once every core-level error has surfaced from the
+// build itself (async/circular forwardTo throw in registerAllRouteHandlers /
+// refreshForwardMap; invalid path constraint throws in rebuildTree). The store
+// is mutated only by `adoptRouteArtifacts`, which cannot throw — so a rejected
+// build leaves the existing routes untouched. The two silent-corruption cases
+// route-tree never throws on (duplicate name vs an existing route, missing
+// parent) are caught up front by `assertAddable`.
 // =============================================================================
 
-export function createRoutesStore<
+/**
+ * The fully-built, ready-to-swap result of preparing a route mutation. Holds
+ * everything `adoptRouteArtifacts` assigns into the store.
+ */
+interface RouteArtifacts<
   Dependencies extends DefaultDependencies = DefaultDependencies,
->(
-  routes: Route<Dependencies>[],
-  matcherOptions?: CreateMatcherOptions,
-): RoutesStore<Dependencies> {
-  const definitions: RouteDefinition[] = [];
-  const config: RouteConfig = createEmptyConfig();
-  const routeCustomFields: Record<
-    string,
-    Record<string, unknown>
-  > = Object.create(null) as Record<string, Record<string, unknown>>;
-  const pendingCanActivate = new Map<string, GuardFnFactory<Dependencies>>();
-  const pendingCanDeactivate = new Map<string, GuardFnFactory<Dependencies>>();
+> {
+  readonly definitions: RouteDefinition[];
+  readonly config: RouteConfig;
+  readonly routeCustomFields: Record<string, Record<string, unknown>>;
+  readonly pendingCanActivate: Map<string, GuardFnFactory<Dependencies>>;
+  readonly pendingCanDeactivate: Map<string, GuardFnFactory<Dependencies>>;
+  readonly tree: RouteTree;
+  readonly matcher: Matcher;
+  readonly resolvedForwardMap: Record<string, string>;
+}
 
+/** Null-proto shallow clone of a RouteConfig (preserves the 5 maps' contents). */
+function cloneConfig(config: RouteConfig): RouteConfig {
+  const clone = createEmptyConfig();
+
+  Object.assign(clone.decoders, config.decoders);
+  Object.assign(clone.encoders, config.encoders);
+  Object.assign(clone.defaultParams, config.defaultParams);
+  Object.assign(clone.forwardMap, config.forwardMap);
+  Object.assign(clone.forwardFnMap, config.forwardFnMap);
+
+  return clone;
+}
+
+/**
+ * Returns a new definitions array with `added` inserted, without mutating the
+ * input. For a top-level add the existing definitions are shallow-copied and
+ * `added` appended. For a parented add the spine down to the parent is cloned
+ * (siblings/other branches are shared by reference) and `added` appended to the
+ * parent's children. Caller guarantees the parent path exists (see assertAddable).
+ */
+function insertAddedDefinitions(
+  definitions: readonly RouteDefinition[],
+  added: RouteDefinition[],
+  parentSegments: readonly string[],
+): RouteDefinition[] {
+  if (parentSegments.length === 0) {
+    return [...definitions, ...added];
+  }
+
+  const [head, ...rest] = parentSegments;
+
+  return definitions.map((def) => {
+    if (def.name !== head) {
+      return def;
+    }
+
+    const children = def.children ?? [];
+
+    return {
+      ...def,
+      children:
+        rest.length === 0
+          ? [...children, ...added]
+          : insertAddedDefinitions(children, added, rest),
+    };
+  });
+}
+
+/** Depth-first walk yielding each route's full dotted name (no side effects). */
+function walkRouteNames<Dependencies extends DefaultDependencies>(
+  routes: readonly Route<Dependencies>[],
+  parentName: string,
+  onName: (fullName: string) => void,
+): void {
   for (const route of routes) {
-    definitions.push(sanitizeRoute(route));
+    const fullName = parentName ? `${parentName}.${route.name}` : route.name;
+
+    onName(fullName);
+
+    if (route.children) {
+      walkRouteNames(route.children, fullName, onName);
+    }
+  }
+}
+
+/**
+ * Up-front guard for `add` against the two corruptions route-tree stays silent
+ * on: a missing `parent`, and a name that collides with an EXISTING route
+ * (which would otherwise be silently overwritten). Throws before any build.
+ */
+export function assertAddable<Dependencies extends DefaultDependencies>(
+  store: RoutesStore<Dependencies>,
+  routes: readonly Route<Dependencies>[],
+  parentName: string | undefined,
+): void {
+  if (parentName !== undefined && !store.matcher.hasRoute(parentName)) {
+    throw new Error(
+      `[router.addRoute] Parent route "${parentName}" does not exist`,
+    );
   }
 
-  const { tree, matcher } = rebuildTree(definitions, "", matcherOptions);
+  walkRouteNames(routes, parentName ?? "", (fullName) => {
+    if (store.matcher.hasRoute(fullName)) {
+      throw new Error(`[router.addRoute] Route "${fullName}" already exists`);
+    }
+  });
+}
+
+/**
+ * Builds RouteArtifacts from a final definitions array and the routes whose
+ * handlers (config + guards) populate `config`/`routeCustomFields`. Guards are
+ * collected into the returned pending maps (depsStore is intentionally omitted
+ * so nothing compiles or touches the lifecycle here). THROWS on async/circular
+ * forwardTo and invalid path constraint — before the caller mutates the store.
+ */
+function buildArtifacts<Dependencies extends DefaultDependencies>(
+  definitions: RouteDefinition[],
+  routesForHandlers: readonly Route<Dependencies>[],
+  config: RouteConfig,
+  routeCustomFields: Record<string, Record<string, unknown>>,
+  handlerParentName: string,
+  rootPath: string,
+  matcherOptions: CreateMatcherOptions | undefined,
+): RouteArtifacts<Dependencies> {
+  const pendingCanActivate = new Map<string, GuardFnFactory<Dependencies>>();
+  const pendingCanDeactivate = new Map<string, GuardFnFactory<Dependencies>>();
 
   registerAllRouteHandlers(
-    routes,
+    routesForHandlers,
     config,
     routeCustomFields,
     pendingCanActivate,
     pendingCanDeactivate,
-    undefined,
-    "",
+    handlerParentName,
   );
 
   const resolvedForwardMap = refreshForwardMap(config);
+  const { tree, matcher } = rebuildTree(definitions, rootPath, matcherOptions);
 
   return {
     definitions,
     config,
+    routeCustomFields,
+    pendingCanActivate,
+    pendingCanDeactivate,
     tree,
     matcher,
     resolvedForwardMap,
-    routeCustomFields,
+  };
+}
+
+/** Builds the merged artifacts for an incremental `add` (existing ∪ new). */
+export function buildAddArtifacts<Dependencies extends DefaultDependencies>(
+  store: RoutesStore<Dependencies>,
+  routes: readonly Route<Dependencies>[],
+  parentName: string | undefined,
+): RouteArtifacts<Dependencies> {
+  const definitions = insertAddedDefinitions(
+    store.definitions,
+    routes.map((route) => sanitizeRoute(route)),
+    parentName === undefined ? [] : parentName.split("."),
+  );
+
+  return buildArtifacts(
+    definitions,
+    routes,
+    cloneConfig(store.config),
+    Object.assign(
+      Object.create(null) as Record<string, Record<string, unknown>>,
+      store.routeCustomFields,
+    ),
+    parentName ?? "",
+    store.rootPath,
+    store.matcherOptions,
+  );
+}
+
+/** Builds the fresh artifacts for a full `replace` (standalone new set). */
+export function buildReplaceArtifacts<Dependencies extends DefaultDependencies>(
+  routes: readonly Route<Dependencies>[],
+  rootPath: string,
+  matcherOptions: CreateMatcherOptions | undefined,
+): RouteArtifacts<Dependencies> {
+  return buildArtifacts(
+    routes.map((route) => sanitizeRoute(route)),
+    routes,
+    createEmptyConfig(),
+    Object.create(null) as Record<string, Record<string, unknown>>,
+    "",
+    rootPath,
+    matcherOptions,
+  );
+}
+
+/**
+ * Commits prepared artifacts into the store in place. Pure assignment — never
+ * throws — so it is the single atomic swap point of the prepare-then-commit
+ * pipeline. Guard registration is deferred to here (the build collected guards
+ * without compiling); `depsStore` is always set on a wired router, which is the
+ * only path that reaches `add`/`replace`.
+ */
+export function adoptRouteArtifacts<Dependencies extends DefaultDependencies>(
+  store: RoutesStore<Dependencies>,
+  artifacts: RouteArtifacts<Dependencies>,
+): void {
+  store.definitions.length = 0;
+
+  for (const def of artifacts.definitions) {
+    store.definitions.push(def);
+  }
+
+  Object.assign(store.config, artifacts.config);
+  store.routeCustomFields = artifacts.routeCustomFields;
+  store.tree = artifacts.tree;
+  store.matcher = artifacts.matcher;
+  store.resolvedForwardMap = artifacts.resolvedForwardMap;
+
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- depsStore is set once the router is wired; add/replace only run on a wired router (constructor-time registration uses createRoutesStore)
+  const deps = store.depsStore!;
+
+  for (const [name, handler] of artifacts.pendingCanActivate) {
+    deps.addActivateGuard(name, handler);
+  }
+
+  for (const [name, handler] of artifacts.pendingCanDeactivate) {
+    deps.addDeactivateGuard(name, handler);
+  }
+}
+
+// =============================================================================
+// Factory
+// =============================================================================
+
+export function createRoutesStore<
+  Dependencies extends DefaultDependencies = DefaultDependencies,
+>(
+  routes: Route<Dependencies>[],
+  matcherOptions?: CreateMatcherOptions,
+): RoutesStore<Dependencies> {
+  // Initial routes are a standalone set at rootPath "" — same build the
+  // prepare-then-commit `replace` path uses. Guards land in the pending maps
+  // (depsStore is wired later via setDependencies, which flushes them).
+  const artifacts = buildReplaceArtifacts(routes, "", matcherOptions);
+
+  return {
+    definitions: artifacts.definitions,
+    config: artifacts.config,
+    tree: artifacts.tree,
+    matcher: artifacts.matcher,
+    resolvedForwardMap: artifacts.resolvedForwardMap,
+    routeCustomFields: artifacts.routeCustomFields,
     rootPath: "",
     matcherOptions,
     depsStore: undefined,
     lifecycleNamespace: undefined,
-    pendingCanActivate,
-    pendingCanDeactivate,
+    pendingCanActivate: artifacts.pendingCanActivate,
+    pendingCanDeactivate: artifacts.pendingCanDeactivate,
     treeOperations: {
       commitTreeChanges,
       resetStore,

package/src/transitionPath.ts

@@ -86,10 +86,14 @@ function nameToIDsGeneral(name: string): string[] {
   return ids;
 }
 
-function isPrimitive(value: unknown): value is PrimitiveParam {
-  const type = typeof value;
+const PRIMITIVE_TYPES: ReadonlySet<string> = new Set([
+  "string",
+  "number",
+  "boolean",
+]);
 
-  return type === "string" || type === "number" || type === "boolean";
+function isPrimitive(value: unknown): value is PrimitiveParam {
+  return PRIMITIVE_TYPES.has(typeof value);
 }
 
 /**

package/src/types.ts

@@ -15,6 +15,7 @@ import type {
   RouterError as RouterErrorType,
   RouteTreeState,
   State,
+  TreeChangedEvent,
 } from "@real-router/types";
 
 // Re-export from @real-router/types (canonical source)
@@ -27,10 +28,16 @@ export type {
 } from "@real-router/types";
 
 /**
- * Event argument tuples for the router's 7 events.
+ * Event argument tuples for the router's 7 transition events plus the internal
+ * `TREE_CHANGED` channel.
  *
  * Uses explicit `| undefined` unions (not optional `?`) to satisfy
  * `exactOptionalPropertyTypes` when passing undefined args from FSM payloads.
+ *
+ * `TREE_CHANGED` is an **internal-only** key: it is deliberately absent from the
+ * public `EventName` union / `events.*` registry / `Plugin` interface. It
+ * reuses the same `EventEmitter` (depth tracking, error isolation) but is only
+ * reachable via `getRoutesApi(router).subscribeChanges()`.
  */
 // eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- must be `type` for Record<string, unknown[]> constraint
 export type RouterEventMap = {
@@ -49,6 +56,7 @@ export type RouterEventMap = {
     error: RouterErrorType | undefined,
   ];
   $$cancel: [toState: State, fromState: State | undefined];
+  TREE_CHANGED: [event: TreeChangedEvent];
 };
 
 /**

package/dist/cjs/Router-CJihdrWA.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Router-CJihdrWA.d.ts","names":[],"sources":["../../src/types.ts","../../src/Router.ts"],"mappings":";;;;;;KAwDY,MAAA,GAAS,QAAQ,CAAC,YAAA;;;;;;;;UASb,4BAAA,WAAuC,MAAA,GAAS,MAAA;EAAA,SACtD,KAAA,EAAO,cAAA,CAAe,CAAA;EAAA,SACtB,QAAA;AAAA;;;;AAXX;;;;AAA0C;AAS1C;;;;;;;;;;cCOa,QAAA,sBACU,mBAAA,GAAsB,mBAAA,aAChC,MAAA,CAAgB,YAAA;EAAA;GAC1B,GAAA;EDTe;;;;AACC;cCoCf,MAAA,GAAQ,KAAA,CAAM,YAAA,KACd,OAAA,GAAS,OAAA,CAAQ,OAAA,GACjB,YAAA,GAAc,YAAA;EA8NhB,aAAA,CACE,IAAA,UACA,MAAA,GAAS,MAAA,EACT,cAAA,YACA,iBAAA;EAgCF,SAAA,CAAU,KAAA,UAAe,MAAA,GAAS,MAAA;EAalC,QAAA,WAAmB,MAAA,GAAS,MAAA,CAAA,CAAA,GAAW,KAAA,CAAM,CAAA;EAI7C,gBAAA,CAAA,GAAoB,KAAA;EAIpB,cAAA,CACE,MAAA,EAAQ,KAAA,cACR,MAAA,EAAQ,KAAA,cACR,iBAAA;EAWF,gBAAA,CACE,QAAA,YACE,OAAA,EAAS,KAAA,EAAO,SAAA,GAAY,KAAA;EAUhC,QAAA,CAAA;EAIA,KAAA,CAAM,SAAA,WAAoB,OAAA,CAAQ,KAAA;EAqClC,IAAA,CAAA;EAcA,OAAA,CAAA;EA8CA,aAAA,CAAc,IAAA,UAAc,MAAA,GAAS,MAAA;EA+BrC,SAAA,CAAA,GACK,OAAA,GAAU,aAAA,CAAc,YAAA,kCAC1B,WAAA;EA2BH,SAAA,CAAU,QAAA,EAAU,WAAA,GAAc,WAAA;EAMlC,cAAA,CAAe,QAAA,EAAU,OAAA,GAAU,WAAA;EAMnC,eAAA,CAAA;EAQA,QAAA,CACE,SAAA,UACA,WAAA,GAAc,MAAA,EACd,OAAA,GAAU,iBAAA,GACT,OAAA,CAAQ,KAAA;EA4BX,iBAAA,CAAkB,OAAA,GAAU,iBAAA,GAAoB,OAAA,CAAQ,KAAA;EAyBxD,kBAAA,CAAmB,IAAA,YAAgB,KAAA;AAAA"}