@astryxdesign/core 0.4.7 → 0.5.0-canary.009bcb3

package/dist/Layer/useLayer.js

@@ -5,7 +5,7 @@
 /**
  * @file useLayer.tsx
  * @input Uses React hooks, Popover API, CSS anchor positioning, typography tokens
- * @output Exports useLayer hook for layer positioning and visibility
+ * @output Exports the public useLayer hook plus internal trigger helpers.
  * @position Core layer utility; used by useHoverCard, useTooltip, etc.
  *
  * SYNC: When modified, update:
@@ -13,10 +13,11 @@
  * - /packages/core/src/Layer/useLayer.test.tsx
  * - /packages/core/src/Layer/index.ts
  */
-import React, { useCallback, useEffect, useId, useRef, useState } from 'react';
+import React, { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react';
 import * as stylex from '@stylexjs/stylex';
 import { createPortal } from 'react-dom';
 import { addAnchorName, removeAnchorName } from "./anchorName.js";
+import { currentGesture, currentGestureHasClicked } from "./gestureCounter.js";
 import { resolveLayerPortalTarget } from "./layerHost.js";
 import "../theme/tokens.stylex.js";
 import { typeScaleVars, typographyVars } from "../theme/tokens.stylex.js";
@@ -64,6 +65,10 @@ const styles = {
   }]
 };
 
+/**
+ * Props for a control that sits on the trigger but must not dismiss the layer.
+ */
+
 /**
  * Position placement relative to anchor.
  * Logical: start/end resolve against the popover's own inherited direction
@@ -188,6 +193,44 @@ export function getPositionTryFallbacks(placement = 'above', alignment = 'center
   return `${flips}, ${same} span-top, ${same} span-bottom, ${opposite} span-top, ${opposite} span-bottom`;
 }
 
+/**
+ * Internal props for controls that sit beside an open layer. This stays out of
+ * the public useLayer/usePopover return types until the input family adopts it.
+ */
+export function useKeepLayerOpenProps(id, isOpen) {
+  const isOpenRef = useRef(isOpen);
+  isOpenRef.current = isOpen;
+  return useMemo(() => ({
+    onPointerDown: event => {
+      if (!isOpenRef.current) {
+        return;
+      }
+      // The browser reads the invoker relationship at both ends of the press.
+      const control = event.currentTarget;
+      const doc = control.ownerDocument;
+      control.setAttribute('popovertarget', id);
+      const onPressEnd = () => {
+        doc.removeEventListener('pointerup', onPressEnd);
+        doc.removeEventListener('pointercancel', onPressEnd);
+        // Light dismiss runs as the pointerup default action after listeners.
+        doc.defaultView?.setTimeout(() => {
+          control.removeAttribute('popovertarget');
+        }, 0);
+      };
+      doc.addEventListener('pointerup', onPressEnd);
+      doc.addEventListener('pointercancel', onPressEnd);
+    },
+    onClickCapture: event => {
+      const control = event.currentTarget;
+      if (control.hasAttribute('popovertarget')) {
+        // Being an invoker would otherwise toggle the layer shut.
+        event.preventDefault();
+        control.removeAttribute('popovertarget');
+      }
+    }
+  }), [id]);
+}
+
 /**
  * Core layer hook that handles popover behavior and positioning.
  *
@@ -202,8 +245,7 @@ export function getPositionTryFallbacks(placement = 'above', alignment = 'center
  * {layer.render(<Content />, { placement: 'above', alignment: 'center' })}
  * ```
  */
-
-export function useLayer(options) {
+function useLayerImplementation(options) {
   const {
     mode,
     onShow,
@@ -234,6 +276,16 @@ export function useLayer(options) {
   // State drives re-renders; the ref lets the imperative calls avoid
   // stale-closure reads of the previous isOpen value.
   const isOpenRef = useRef(false);
+
+  // The gesture during which the browser last closed this layer on its own.
+  // Read through wasJustDismissed by triggers deciding whether a click is
+  // theirs to act on.
+  const dismissedByGestureRef = useRef(null);
+  const forgetDismissalRef = useRef(null);
+  const wasJustDismissed = useCallback(() => {
+    const gesture = currentGesture();
+    return dismissedByGestureRef.current === gesture;
+  }, []);
   const showPopoverElement = useCallback(popover => {
     // Finding infra-4: the Popover API is unsupported on Safari <17 and
     // Firefox <125. On those browsers `showPopover` does not exist, so fall
@@ -287,6 +339,11 @@ export function useLayer(options) {
     setContextMount(null);
   }, [mode, lazyMount]);
   const show = useCallback(() => {
+    // Every caller lands here, so this is where the dismissing press is
+    // absorbed: opening now would reopen the popup that same press closed.
+    if (wasJustDismissed()) {
+      return;
+    }
     // A context popover left over until React commits a previous hide must not
     // be reopened. The synchronous mount ref is the source of truth.
     const candidate = popoverRef.current;
@@ -302,11 +359,16 @@ export function useLayer(options) {
       setIsOpen(true);
       onShow?.();
     }
-  }, [onShow, requestContextMount, showPopoverElement, isCurrentContextPopover]);
+  }, [onShow, requestContextMount, showPopoverElement, isCurrentContextPopover, wasJustDismissed]);
   const hide = useCallback(() => {
     pendingShowRef.current = false;
     if (isOpenRef.current) {
       const el = popoverRef.current;
+      // Clear the open state BEFORE hiding: hidePopover fires `toggle`, and
+      // the reconciler below reads this ref to tell the browser's own
+      // dismissals from ours.
+      openedPopoverRef.current = null;
+      isOpenRef.current = false;
       // See finding infra-4 note in `show`: mirror the same guard on hide so
       // unsupported browsers degrade gracefully instead of throwing.
       if (el) {
@@ -316,8 +378,6 @@ export function useLayer(options) {
           el.style.display = 'none';
         }
       }
-      openedPopoverRef.current = null;
-      isOpenRef.current = false;
       setIsOpen(false);
       onHide?.();
     }
@@ -337,6 +397,50 @@ export function useLayer(options) {
     triggerRef.current = el;
   } : undefined;
 
+  // Arm only when the dismissing gesture's click is still ahead of us. Some
+  // engines deliver click first; in that order there is nothing left to absorb.
+  const rememberDismissal = useCallback(doc => {
+    forgetDismissalRef.current?.();
+    if (currentGestureHasClicked()) {
+      return;
+    }
+    dismissedByGestureRef.current = currentGesture();
+    const view = doc.defaultView;
+    let forgetTimer = null;
+    const forget = () => {
+      dismissedByGestureRef.current = null;
+      doc.removeEventListener('click', scheduleForget, true);
+      if (forgetTimer !== null) {
+        view?.clearTimeout(forgetTimer);
+        forgetTimer = null;
+      }
+      if (forgetDismissalRef.current === forget) {
+        forgetDismissalRef.current = null;
+      }
+    };
+    const scheduleForget = () => {
+      doc.removeEventListener('click', scheduleForget, true);
+      // The next task keeps the dismissal armed through React's click handler.
+      if (view) {
+        forgetTimer = view.setTimeout(() => {
+          forgetTimer = null;
+          if (forgetDismissalRef.current === forget) {
+            forget();
+          }
+        }, 0);
+      } else {
+        forget();
+      }
+    };
+    doc.addEventListener('click', scheduleForget, true);
+    forgetDismissalRef.current = forget;
+  }, []);
+  useEffect(() => {
+    // Install capture-phase gesture tracking before the first interaction.
+    currentGesture();
+    return () => forgetDismissalRef.current?.();
+  }, []);
+
   // Reconcile browser-initiated closes (light-dismiss, popover="auto" stack
   // eviction). These are the only cases where the DOM mutates without going
   // through our show/hide — we sync React state back to match.
@@ -352,11 +456,12 @@ export function useLayer(options) {
     if (toggleEvent.newState === 'closed' && isOpenRef.current) {
       openedPopoverRef.current = null;
       isOpenRef.current = false;
+      rememberDismissal(e.currentTarget?.ownerDocument ?? document);
       setIsOpen(false);
       onHide?.();
       clearContextMount();
     }
-  }, [onHide, clearContextMount]);
+  }, [onHide, clearContextMount, rememberDismissal]);
 
   // Ref callback for popover element — sets up the `toggle` listener.
   // Tracks the element + handler currently bound so the listener is removed
@@ -519,6 +624,7 @@ export function useLayer(options) {
       show,
       hide,
       isOpen,
+      wasJustDismissed,
       id,
       render: renderContext
     };
@@ -528,7 +634,21 @@ export function useLayer(options) {
     show,
     hide,
     isOpen,
+    wasJustDismissed,
     id,
     render: renderFixed
   };
+}
+export function useLayer(options) {
+  const {
+    wasJustDismissed: _,
+    ...layer
+  } = useLayerImplementation(options);
+  return layer;
+}
+
+/** @internal Shared with usePopover; not exported from the package barrel. */
+
+export function useLayerInternal(options) {
+  return useLayerImplementation(options);
 }

package/dist/Layer/useLayerDismissal.d.ts

@@ -0,0 +1,93 @@
+import { type LayerEscapeBehavior } from './layerStack';
+export type { LayerEscapeBehavior };
+export interface UseLayerDismissalOptions {
+    /**
+     * Whether this layer is participating right now. Usually the layer's open
+     * state. A layer whose open state lags the DOM should pass `true` for its
+     * lifetime and answer `isPresent` from the DOM instead.
+     */
+    isActive: boolean;
+    /**
+     * Dismiss this layer. Called by the stack when this layer is the one that
+     * should respond to an Escape press. Not called for `escapeBehavior: 'block'`.
+     */
+    onDismiss: () => void;
+    /**
+     * What this layer does with an Escape press that reaches it.
+     * @default 'close'
+     */
+    escapeBehavior?: LayerEscapeBehavior;
+    /**
+     * This layer's container element, read lazily. Optional: supply it when the
+     * layer cannot wrap its content in `LayerDepthProvider` (a bare focus trap
+     * renders nothing), so nesting can still be recovered from the DOM.
+     */
+    getContainer?: () => HTMLElement | null;
+    /**
+     * Whether the layer is really on screen, asked at press time. Supply it when
+     * `isActive` is `true` for the layer's lifetime because its open state lags
+     * the DOM by a frame; the stack skips layers that answer `false`.
+     */
+    isPresent?: () => boolean;
+    /**
+     * Whether this layer takes part in the shared stack at all. When `false` the
+     * layer is invisible to dismissal: a press flows past it to the layer below,
+     * exactly as if it were not open.
+     *
+     * Deliberately separate from `escapeBehavior: 'block'` — `'block'` is a layer
+     * that is present and swallows the press; this is a layer that is not there
+     * at all. One case uses it: `Dialog`'s inline rendering mode, where content
+     * sits in normal flow with nothing layered over anything.
+     *
+     * A controlled layer is NOT one of these. It stays registered and takes the
+     * press like any other, answering it by calling the consumer's change
+     * handler; whether it then closes is the consumer's decision.
+     *
+     * Layers that are never Escape-dismissible (toasts) should simply not call
+     * this hook.
+     *
+     * @default true
+     */
+    isEnabled?: boolean;
+}
+export interface UseLayerDismissalReturn {
+    /**
+     * Whether a close request the browser started on its own — a `<dialog>`'s
+     * `cancel`, the Android back gesture, the platform close watcher — should
+     * dismiss this layer. As well as the top-most rule the stack applies to an
+     * Escape press, it declines a request that arrives while an IME composition
+     * is running, which no `cancel` handler can tell on its own because the
+     * event carries no composition state.
+     */
+    shouldDismissOnCloseRequest: () => boolean;
+}
+/**
+ * Join the shared layer dismissal stack for as long as this layer is active.
+ *
+ * The layer does NOT attach a key listener — the stack owns one listener and
+ * routes each Escape press to the top-most REGISTERED layer, so one press
+ * dismisses exactly one of them. Dialog (and what is built on it), Popover and
+ * the menus built on it, Tooltip, HoverCard, Lightbox and MobileNav register
+ * today; `BottomSheetSwitcher` registers through its focus trap when modal and
+ * still handles its own press when not.
+ *
+ * `BottomSheet`, `CommandPalette`, `ContextMenu`, `DropdownMenuSubMenu`,
+ * `PowerSearchEditPopover` and lab's `Drawer` still run their own Escape
+ * listener. They stay safe next to the stack only because each claims the press
+ * at element level, and the stack stands down on an already-`defaultPrevented`
+ * press — but a registered layer opened INSIDE one of them does not get the
+ * press: the host takes it and closes instead. Migrating them is the fix.
+ *
+ * Wrap the layer's own content in `LayerDepthProvider` so anything opened from
+ * inside it registers as nested.
+ *
+ * @example
+ * ```tsx
+ * useLayerDismissal({
+ *   isActive: isOpen,
+ *   onDismiss: () => onOpenChange(false),
+ * });
+ * ```
+ */
+export declare function useLayerDismissal(options: UseLayerDismissalOptions): UseLayerDismissalReturn;
+//# sourceMappingURL=useLayerDismissal.d.ts.map

package/dist/Layer/useLayerDismissal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLayerDismissal.d.ts","sourceRoot":"","sources":["../../src/Layer/useLayerDismissal.ts"],"names":[],"mappings":"AAqBA,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,cAAc,CAAC;AAEtB,YAAY,EAAC,mBAAmB,EAAC,CAAC;AAElC,MAAM,WAAW,wBAAwB;IACvC;;;;OAIG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB;;;OAGG;IACH,cAAc,CAAC,EAAE,mBAAmB,CAAC;IACrC;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,WAAW,GAAG,IAAI,CAAC;IACxC;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC;IAC1B;;;;;;;;;;;;;;;;;;OAkBG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,uBAAuB;IACtC;;;;;;;OAOG;IACH,2BAA2B,EAAE,MAAM,OAAO,CAAC;CAC5C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,wBAAwB,GAChC,uBAAuB,CAiDzB"}

package/dist/Layer/useLayerDismissal.js

@@ -0,0 +1,91 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file useLayerDismissal.ts
+ * @input Uses React hooks, the layer stack, and LayerDepthContext
+ * @output Exports useLayerDismissal + its option/return types
+ * @position The API overlays use to join the shared dismissal stack. Wraps
+ *   layerStack (registration + the single Escape listener) and reads nesting
+ *   depth from LayerDepthContext.
+ *
+ * SYNC: When modified, update:
+ * - /packages/core/src/Layer/index.ts
+ * - /packages/core/src/Layer/useLayerDismissal.test.tsx
+ * - /packages/core/src/Layer/layerStack.ts
+ */
+import { useCallback, useEffect, useRef } from 'react';
+import { useLayerDepth } from "./LayerDepthContext.js";
+import { isTextComposing, isTopmostLayer, registerLayer } from "./layerStack.js";
+/**
+ * Join the shared layer dismissal stack for as long as this layer is active.
+ *
+ * The layer does NOT attach a key listener — the stack owns one listener and
+ * routes each Escape press to the top-most REGISTERED layer, so one press
+ * dismisses exactly one of them. Dialog (and what is built on it), Popover and
+ * the menus built on it, Tooltip, HoverCard, Lightbox and MobileNav register
+ * today; `BottomSheetSwitcher` registers through its focus trap when modal and
+ * still handles its own press when not.
+ *
+ * `BottomSheet`, `CommandPalette`, `ContextMenu`, `DropdownMenuSubMenu`,
+ * `PowerSearchEditPopover` and lab's `Drawer` still run their own Escape
+ * listener. They stay safe next to the stack only because each claims the press
+ * at element level, and the stack stands down on an already-`defaultPrevented`
+ * press — but a registered layer opened INSIDE one of them does not get the
+ * press: the host takes it and closes instead. Migrating them is the fix.
+ *
+ * Wrap the layer's own content in `LayerDepthProvider` so anything opened from
+ * inside it registers as nested.
+ *
+ * @example
+ * ```tsx
+ * useLayerDismissal({
+ *   isActive: isOpen,
+ *   onDismiss: () => onOpenChange(false),
+ * });
+ * ```
+ */
+export function useLayerDismissal(options) {
+  const {
+    isActive,
+    onDismiss,
+    escapeBehavior = 'close',
+    getContainer,
+    isPresent,
+    isEnabled = true
+  } = options;
+  const depth = useLayerDepth();
+
+  // Identity for this layer's stack entry, stable across re-registration.
+  const tokenRef = useRef({});
+
+  // The stack calls these during an event, outside React's render, so they must
+  // reach the latest closures rather than the ones captured at registration.
+  const onDismissRef = useRef(onDismiss);
+  const getContainerRef = useRef(getContainer);
+  const isPresentRef = useRef(isPresent);
+  useEffect(() => {
+    onDismissRef.current = onDismiss;
+    getContainerRef.current = getContainer;
+    isPresentRef.current = isPresent;
+  });
+  const isRegistered = isActive && isEnabled;
+  useEffect(() => {
+    if (!isRegistered) {
+      return;
+    }
+    return registerLayer({
+      token: tokenRef.current,
+      depth,
+      behavior: escapeBehavior,
+      getContainer: () => getContainerRef.current?.() ?? null,
+      isPresent: () => isPresentRef.current?.() ?? true,
+      dismiss: () => onDismissRef.current()
+    });
+  }, [isRegistered, depth, escapeBehavior]);
+  const shouldDismissOnCloseRequest = useCallback(() => isRegistered && !isTextComposing() && isTopmostLayer(tokenRef.current), [isRegistered]);
+  return {
+    shouldDismissOnCloseRequest
+  };
+}

package/dist/Lightbox/Lightbox.d.ts

@@ -8,6 +8,7 @@
  * - /packages/core/src/Lightbox/Lightbox.doc.mjs (props table, features, implementation notes)
  * - /packages/core/src/Lightbox/Lightbox.test.tsx (tests for new/changed behavior)
  * - /packages/core/src/Lightbox/index.ts (exports if types change)
+ * - /packages/core/src/Layer/useLayerDismissal.ts (dismissal stack)
  * - /apps/storybook/stories/Lightbox.stories.tsx (storybook stories)
  * - /packages/cli/assets/templates/blocks/components/Lightbox/ (showcase blocks)
  */

package/dist/Lightbox/Lightbox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Lightbox.d.ts","sourceRoot":"","sources":["../../src/Lightbox/Lightbox.tsx"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAOL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AASf,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AAM5C;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,OAAO,CAAC;AAElD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,uBAAuB;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,gEAAgE;IAChE,GAAG,EAAE,MAAM,CAAC;IACZ,iDAAiD;IACjD,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB;;;OAGG;IACH,IAAI,CAAC,EAAE,iBAAiB,CAAC;CAC1B;AAED,MAAM,WAAW,aAAc,SAAQ,SAAS,CAAC,iBAAiB,CAAC;IACjE,+CAA+C;IAC/C,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;IACnC;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,YAAY,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IACxC;;;OAGG;IACH,KAAK,EAAE,aAAa,GAAG,aAAa,EAAE,CAAC;IACvC;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AA+JD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,QAAQ,CAAC,EACvB,MAAM,EACN,YAAY,EACZ,KAAK,EACL,KAAK,EAAE,eAAe,EACtB,YAAgB,EAChB,aAAa,EACb,OAAe,EACf,WAAmB,EACnB,MAAM,EACN,SAAS,EACT,KAAK,EACL,GAAG,EACH,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,aAAa,EACxB,GAAG,KAAK,EACT,EAAE,aAAa,sCA6Yf;yBA7Ze,QAAQ"}
+{"version":3,"file":"Lightbox.d.ts","sourceRoot":"","sources":["../../src/Lightbox/Lightbox.tsx"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAOL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AASf,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AAS5C;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,OAAO,CAAC;AAElD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,uBAAuB;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,gEAAgE;IAChE,GAAG,EAAE,MAAM,CAAC;IACZ,iDAAiD;IACjD,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB;;;OAGG;IACH,IAAI,CAAC,EAAE,iBAAiB,CAAC;CAC1B;AAED,MAAM,WAAW,aAAc,SAAQ,SAAS,CAAC,iBAAiB,CAAC;IACjE,+CAA+C;IAC/C,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;IACnC;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,YAAY,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IACxC;;;OAGG;IACH,KAAK,EAAE,aAAa,GAAG,aAAa,EAAE,CAAC;IACvC;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AA+JD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,QAAQ,CAAC,EACvB,MAAM,EACN,YAAY,EACZ,KAAK,EACL,KAAK,EAAE,eAAe,EACtB,YAAgB,EAChB,aAAa,EACb,OAAe,EACf,WAAmB,EACnB,MAAM,EACN,SAAS,EACT,KAAK,EACL,GAAG,EACH,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,aAAa,EACxB,GAAG,KAAK,EACT,EAAE,aAAa,sCA+Zf;yBA/ae,QAAQ"}