@proyecto-viviana/solid-stately 0.5.1 → 0.6.0-rc.1

package/src/tooltip/createTooltipTriggerState.ts

@@ -1,3 +1,17 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/tooltip/useTooltipTriggerState.ts
+
 /**
  * Manages state for a tooltip trigger.
  * Based on @react-stately/tooltip useTooltipTriggerState.
@@ -6,9 +20,11 @@
  * Ensures only one tooltip is open at a time and controls the delay for showing a tooltip.
  */
 
-import { createSignal, onCleanup, type Accessor } from "solid-js";
+import { flush, onCleanup } from "solid-js";
+import type { Accessor } from "solid-js";
 import { createOverlayTriggerState, type OverlayTriggerProps } from "../overlays";
 import { isServer } from "../ssr";
+import { createInternalSignal } from "../utils";
 
 // Default delays (in ms)
 const TOOLTIP_DELAY = 1500;
@@ -19,11 +35,18 @@ export interface TooltipTriggerProps extends OverlayTriggerProps {
   delay?: number;
   /** The delay time in milliseconds for the tooltip to close. */
   closeDelay?: number;
+  /** Whether the tooltip trigger is disabled. */
+  isDisabled?: boolean;
 }
 
 export interface TooltipTriggerState {
   /** Whether the tooltip is currently showing. */
   readonly isOpen: Accessor<boolean>;
+  /**
+   * Whether the tooltip is being shown or hidden without an animation. True while
+   * the global warmup timer is active, i.e. when quickly moving between tooltips.
+   */
+  readonly shouldSkipAnimation: Accessor<boolean>;
   /**
    * Shows the tooltip. By default, the tooltip becomes visible after a delay
    * depending on a global warmup timer. The `immediate` option shows the
@@ -35,7 +58,7 @@ export interface TooltipTriggerState {
 }
 
 // Global state for coordinating tooltips
-let tooltips: Record<string, (immediate?: boolean) => void> = {};
+let tooltips: Record<string, (immediate?: boolean, instant?: boolean) => void> = {};
 let tooltipId = 0;
 let globalWarmedUp = false;
 let globalWarmUpTimeout: ReturnType<typeof setTimeout> | null = null;
@@ -70,9 +93,12 @@ export function createTooltipTriggerState(props: TooltipTriggerProps = {}): Tool
 
   const overlayState = createOverlayTriggerState(props);
   const id = `tooltip-${++tooltipId}`;
+  const [shouldSkipAnimation, setShouldSkipAnimation] = createInternalSignal(false);
 
   let closeTimeout: ReturnType<typeof setTimeout> | null = null;
-  const [closeCallback, setCloseCallback] = createSignal<() => void>(() => overlayState.close());
+  // Solid 2 treats a function initializer as a writable memo, so keep the
+  // close target as a plain binding rather than a function-valued signal.
+  let closeFn = overlayState.close;
 
   const ensureTooltipEntry = () => {
     tooltips[id] = hideTooltip;
@@ -81,21 +107,30 @@ export function createTooltipTriggerState(props: TooltipTriggerProps = {}): Tool
   const closeOpenTooltips = () => {
     for (const hideTooltipId in tooltips) {
       if (hideTooltipId !== id) {
-        tooltips[hideTooltipId](true);
+        tooltips[hideTooltipId](true, true);
         delete tooltips[hideTooltipId];
       }
     }
   };
 
-  const showTooltip = () => {
+  const showTooltip = (instant?: boolean) => {
     if (closeTimeout) {
       clearTimeout(closeTimeout);
       closeTimeout = null;
     }
     closeOpenTooltips();
     ensureTooltipEntry();
+    setShouldSkipAnimation(!!instant);
     globalWarmedUp = true;
     overlayState.open();
+    // Timer callbacks and event handlers can flush. Overlay `Show` otherwise
+    // stays unmounted until a later microtask (fake-timer tests read the DOM
+    // in the same turn as `advanceTimersByTime`).
+    try {
+      flush();
+    } catch {
+      // Ignore: flush is forbidden inside createEffect apply / createTrackedEffect.
+    }
 
     if (globalWarmUpTimeout) {
       clearTimeout(globalWarmUpTimeout);
@@ -107,17 +142,18 @@ export function createTooltipTriggerState(props: TooltipTriggerProps = {}): Tool
     }
   };
 
-  const hideTooltip = (immediate?: boolean) => {
+  const hideTooltip = (immediate?: boolean, instant?: boolean) => {
+    setShouldSkipAnimation(!!instant);
     if (immediate || closeDelay() <= 0) {
       if (closeTimeout) {
         clearTimeout(closeTimeout);
         closeTimeout = null;
       }
-      closeCallback()();
+      closeFn();
     } else if (!closeTimeout) {
       closeTimeout = setTimeout(() => {
         closeTimeout = null;
-        closeCallback()();
+        closeFn();
       }, closeDelay());
     }
 
@@ -149,15 +185,14 @@ export function createTooltipTriggerState(props: TooltipTriggerProps = {}): Tool
       globalWarmUpTimeout = setTimeout(() => {
         globalWarmUpTimeout = null;
         globalWarmedUp = true;
-        showTooltip();
+        showTooltip(false);
       }, delay());
     } else if (!overlayState.isOpen()) {
-      showTooltip();
+      showTooltip(true);
     }
   };
 
-  // Update close callback when overlayState.close changes
-  setCloseCallback(() => overlayState.close);
+  closeFn = overlayState.close;
 
   // Cleanup on unmount
   onCleanup(() => {
@@ -171,12 +206,13 @@ export function createTooltipTriggerState(props: TooltipTriggerProps = {}): Tool
 
   return {
     isOpen: overlayState.isOpen,
+    shouldSkipAnimation,
     open: (immediate?: boolean) => {
       if (isServer) return;
       if (!immediate && delay() > 0 && !closeTimeout) {
         warmupTooltip();
       } else {
-        showTooltip();
+        showTooltip(true);
       }
     },
     close: hideTooltip,

package/src/tree/TreeCollection.ts

@@ -1,3 +1,17 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/tree/TreeCollection.ts
+
 /**
  * TreeCollection implementation.
  * Based on @react-stately/tree/TreeCollection.

package/src/tree/createTreeState.ts

@@ -1,3 +1,17 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/tree/useTreeState.ts
+
 /**
  * Tree state management for Tree components.
  * Based on @react-stately/tree/useTreeState.
@@ -5,18 +19,19 @@
  * Manages expansion state, selection, and focus for hierarchical tree data.
  */
 
-import { createSignal, createEffect, createMemo, on, type Accessor } from "solid-js";
+import { createEffect, createMemo } from "solid-js";
 import type { TreeState, TreeStateOptions, TreeCollection } from "./types";
 import type { Key, FocusStrategy, Selection, SelectionBehavior } from "../collections/types";
+import { createInternalSignal, propsAccessor, type MaybeAccessor } from "../utils";
 
 /**
  * Creates state management for a tree component.
  * Handles expansion, selection, focus management, and keyboard navigation state.
  */
 export function createTreeState<T extends object, C extends TreeCollection<T> = TreeCollection<T>>(
-  options: Accessor<TreeStateOptions<T, C>>,
+  options: MaybeAccessor<TreeStateOptions<T, C>>,
 ): TreeState<T, C> {
-  const getOptions = () => options();
+  const getOptions = propsAccessor(options);
 
   // Disabled keys as a Set
   const disabledKeys = createMemo(() => {
@@ -25,18 +40,19 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
   });
 
   // Expansion state (uncontrolled)
-  const [internalExpandedKeys, setInternalExpandedKeys] = createSignal<Set<Key>>(
+  const [internalExpandedKeys, setInternalExpandedKeys] = createInternalSignal<Set<Key>>(
     getInitialExpandedKeys(getOptions().defaultExpandedKeys),
   );
 
-  // Computed expanded keys (controlled or uncontrolled)
-  const expandedKeys = createMemo(() => {
+  // Live expanded keys (controlled or uncontrolled). A wrapping createMemo
+  // would hide createInternalSignal writes until flush().
+  const expandedKeys = (): Set<Key> => {
     const opts = getOptions();
     if (opts.expandedKeys !== undefined) {
       return new Set(opts.expandedKeys);
     }
     return internalExpandedKeys();
-  });
+  };
 
   // Collection - rebuilt when expanded keys change
   const collection = createMemo(() => {
@@ -45,61 +61,79 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
   });
 
   // Focus state
-  const [isFocused, setIsFocused] = createSignal(false);
-  const [focusedKey, setFocusedKeyInternal] = createSignal<Key | null>(null);
-  const [childFocusStrategy, setChildFocusStrategy] = createSignal<FocusStrategy | null>(null);
-  const [isKeyboardNavigationDisabled, setKeyboardNavigationDisabled] = createSignal(false);
+  const [isFocused, setIsFocused] = createInternalSignal(false);
+  const [focusedKey, setFocusedKeyInternal] = createInternalSignal<Key | null>(null);
+  const [childFocusStrategy, setChildFocusStrategy] = createInternalSignal<FocusStrategy | null>(
+    null,
+  );
+  const [isKeyboardNavigationDisabled, setKeyboardNavigationDisabled] = createInternalSignal(false);
 
   // Selection state
-  const [internalSelectedKeys, setInternalSelectedKeys] = createSignal<"all" | Set<Key>>(
+  const [internalSelectedKeys, setInternalSelectedKeys] = createInternalSignal<"all" | Set<Key>>(
     getInitialSelection(getOptions().defaultSelectedKeys),
   );
-  const [anchorKey, setAnchorKey] = createSignal<Key | null>(null);
+  const [anchorKey, setAnchorKey] = createInternalSignal<Key | null>(null);
 
   // Computed selection
-  const selectedKeys = createMemo(() => {
+  const selectedKeys = (): "all" | Set<Key> => {
     const opts = getOptions();
     if (opts.selectedKeys !== undefined) {
       return normalizeSelection(opts.selectedKeys);
     }
     return internalSelectedKeys();
-  });
+  };
 
   const selectionMode = createMemo(() => getOptions().selectionMode ?? "none");
   const selectionBehaviorProp = (): SelectionBehavior => getOptions().selectionBehavior ?? "toggle";
   const [selectionBehaviorState, setSelectionBehaviorState] =
-    createSignal<SelectionBehavior>(selectionBehaviorProp());
+    createInternalSignal<SelectionBehavior>(selectionBehaviorProp());
   const selectionBehavior = createMemo(() => selectionBehaviorState());
   const disallowEmptySelection = createMemo(() => getOptions().disallowEmptySelection ?? false);
   const disabledBehavior = createMemo(() => getOptions().disabledBehavior ?? "all");
 
-  createEffect(on(selectionBehaviorProp, (behavior) => setSelectionBehaviorState(behavior)));
-
-  createEffect(() => {
-    const keys = selectedKeys();
-    if (
-      selectionBehaviorProp() === "replace" &&
-      selectionBehaviorState() === "toggle" &&
-      keys !== "all" &&
-      keys.size === 0
-    ) {
-      setSelectionBehaviorState("replace");
+  let lastSelectionBehavior = selectionBehaviorProp();
+  createEffect(selectionBehaviorProp, (behavior) => {
+    if (behavior !== lastSelectionBehavior) {
+      setSelectionBehaviorState(behavior);
+      lastSelectionBehavior = behavior;
     }
   });
 
+  createEffect(
+    () => ({
+      prop: selectionBehaviorProp(),
+      keys: selectedKeys(),
+    }),
+    ({ prop, keys }) => {
+      if (
+        prop === "replace" &&
+        selectionBehaviorState() === "toggle" &&
+        keys !== "all" &&
+        keys.size === 0
+      ) {
+        setSelectionBehaviorState("replace");
+      }
+    },
+  );
+
   // Set focused key
   const setFocusedKey = (key: Key | null, strategy: FocusStrategy = "first") => {
     setFocusedKeyInternal(key);
     setChildFocusStrategy(strategy);
   };
 
-  // Reset focused key if the item is removed from visible collection
-  let cachedCollection: C | null = null;
+  // Reset focused key if the item is removed from visible collection.
+  // Seed the cache at factory time so the first flushed effect run can
+  // still see a collapse/removal.
+  let cachedCollection: C | null = collection();
 
   createEffect(
-    on(collection, (coll) => {
-      const currentFocusedKey = focusedKey();
-
+    () => ({
+      coll: collection(),
+      currentFocusedKey: focusedKey(),
+      disabled: disabledKeys(),
+    }),
+    ({ coll, currentFocusedKey, disabled }) => {
       if (currentFocusedKey != null && cachedCollection) {
         // Check if the focused item is still visible
         const visibleKeys = [...coll.getKeys()];
@@ -124,7 +158,7 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
             if (cachedNode?.rowIndex !== undefined) {
               const newIndex = Math.min(cachedNode.rowIndex, rows.length - 1);
               const newNode = rows[newIndex];
-              if (newNode && !disabledKeys().has(newNode.key)) {
+              if (newNode && !disabled.has(newNode.key)) {
                 setFocusedKeyInternal(newNode.key);
                 cachedCollection = coll;
                 return;
@@ -132,7 +166,7 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
             }
             // Fall back to first non-disabled item
             for (const row of rows) {
-              if (!disabledKeys().has(row.key)) {
+              if (!disabled.has(row.key)) {
                 setFocusedKeyInternal(row.key);
                 break;
               }
@@ -144,7 +178,7 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
       }
 
       cachedCollection = coll;
-    }),
+    },
   );
 
   // Selection methods
@@ -240,7 +274,7 @@ export function createTreeState<T extends object, C extends TreeCollection<T> =
       return;
     }
 
-    const anchor = anchorKey();
+    const anchor = anchorKey() ?? focusedKey();
     if (!anchor) {
       replaceSelection(toKey);
       return;

package/src/tree/types.ts

@@ -1,6 +1,23 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/tree/TreeCollection.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/tree/useTreeState.ts
+
 /**
  * Tree collection types for Tree components.
- * Based on @react-stately/tree.
+ * Ported from:
+ * - packages/react-stately/src/tree/TreeCollection.ts
+ * - packages/react-stately/src/tree/useTreeState.ts
  */
 
 import type { Key, FocusStrategy, Selection, SelectionBehavior } from "../collections/types";

package/src/utils/index.ts

@@ -1 +1,10 @@
-export { access, isAccessor, type MaybeAccessor, type MaybeAccessorValue } from "./reactivity";
+export {
+  access,
+  createInternalSignal,
+  isAccessor,
+  propsAccessor,
+  readNow,
+  type MaybeAccessor,
+  type MaybeAccessorValue,
+} from "./reactivity";
+export { useContextOptional } from "./owner";

package/src/utils/owner.ts

@@ -0,0 +1,20 @@
+/**
+ * Solid 2 owner guards. `useContext` throws when there is no reactive root,
+ * even if the context has a default — hook factories (and tests) call
+ * `createFormValidationState` outside a component.
+ */
+
+import { getOwner, useContext } from "solid-js";
+import type { Context } from "solid-js";
+
+/** Read context, or the context default, when called with no owner. */
+export function useContextOptional<T>(context: Context<T>): T {
+  if (!getOwner()) {
+    return context.defaultValue as T;
+  }
+  try {
+    return useContext(context);
+  } catch {
+    return context.defaultValue as T;
+  }
+}

package/src/utils/reactivity.ts

@@ -4,7 +4,8 @@
  * Provides type-safe utilities for working with SolidJS reactivity patterns.
  */
 
-import { Accessor } from "solid-js";
+import { Accessor, createSignal, getObserver } from "solid-js";
+import type { Signal, SignalOptions } from "solid-js";
 
 /**
  * A value that may be either a raw value or an accessor function.
@@ -34,3 +35,54 @@ export type MaybeAccessorValue<T> = T | undefined | Accessor<T | undefined>;
 export function isAccessor<T>(value: MaybeAccessor<T>): value is Accessor<T> {
   return typeof value === "function";
 }
+
+/**
+ * Resolve a props bag once. Later reads call the accessor directly, so a
+ * function-valued field such as `getKey` is never treated as the bag.
+ */
+export function propsAccessor<T extends object>(props: MaybeAccessor<T>): Accessor<T> {
+  return typeof props === "function" ? props : () => props;
+}
+
+/**
+ * Headless state is written from factory setup and from public setters that
+ * tests (and some call sites) invoke inside `createRoot` / a component body.
+ * Solid 2 throws on those writes unless the signal opts into `ownedWrite`.
+ *
+ * Solid 2 also hides unflushed writes from both default reads (unowned /
+ * committed snapshot) and `latest()` (A28: flush first to read your own
+ * write). Headless methods chain read-then-write in the same turn, so the
+ * getter returns a live mirror and still reads the signal for tracking.
+ */
+export function createInternalSignal<T>(value: T, options?: SignalOptions<T>): Signal<T> {
+  let live = value;
+  // Solid's createSignal overloads exclude Function so a function value is a
+  // writable memo. Headless state holds dates, sets, and tokens — cast through.
+  const [get, set] = createSignal(value as never, {
+    ...options,
+    ownedWrite: true,
+  }) as Signal<T>;
+  const read = (() => {
+    // Track only inside a tracking scope (JSX / memo / effect compute).
+    // Calling the signal from an effect apply or unowned method is a
+    // STRICT_READ_UNTRACKED diagnostic; the live mirror is the value.
+    if (getObserver()) get();
+    return live;
+  }) as typeof get;
+  const write = ((next: T | ((prev: T) => T)) => {
+    const resolved = typeof next === "function" ? (next as (prev: T) => T)(live) : next;
+    live = resolved;
+    (set as (v: T) => T)(resolved);
+    return resolved;
+  }) as typeof set;
+  return [read, write];
+}
+
+/**
+ * Same-turn read of a headless accessor. `createInternalSignal` getters
+ * already return the live mirror; this is for call sites that used to wrap
+ * `latest()` (which does not see unflushed writes in Solid 2 rc.9).
+ */
+export function readNow<T>(accessor: Accessor<T>): T {
+  return accessor();
+}

package/src/autocomplete/createAutocompleteState.d.ts

@@ -1,48 +0,0 @@
-/**
- * createAutocompleteState - State management for autocomplete components
- *
- * Based on @react-stately/autocomplete useAutocompleteState.
- */
-import { type Accessor } from "solid-js";
-export interface AutocompleteState {
-  /** The current value of the autocomplete input. */
-  inputValue: Accessor<string>;
-  /** Sets the value of the autocomplete input. */
-  setInputValue(value: string): void;
-  /** The id of the current aria-activedescendant of the autocomplete input. */
-  focusedNodeId: Accessor<string | null>;
-  /** Sets the id of the current aria-activedescendant of the autocomplete input. */
-  setFocusedNodeId(value: string | null): void;
-}
-export interface AutocompleteStateOptions {
-  /** The value of the autocomplete input (controlled). */
-  inputValue?: string;
-  /** The default value of the autocomplete input (uncontrolled). */
-  defaultInputValue?: string;
-  /** Handler that is called when the autocomplete input value changes. */
-  onInputChange?: (value: string) => void;
-}
-/**
- * Provides state management for an autocomplete component.
- *
- * @example
- * ```tsx
- * const state = createAutocompleteState({
- *   defaultInputValue: '',
- *   onInputChange: (value) => console.log('Input changed:', value),
- * });
- *
- * // Access current input value
- * console.log(state.inputValue());
- *
- * // Update input value
- * state.setInputValue('new value');
- *
- * // Track focused node for aria-activedescendant
- * state.setFocusedNodeId('item-1');
- * ```
- */
-export declare function createAutocompleteState(
-  props?: AutocompleteStateOptions,
-): AutocompleteState;
-//# sourceMappingURL=createAutocompleteState.d.ts.map

package/src/autocomplete/createAutocompleteState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createAutocompleteState.d.ts","sourceRoot":"","sources":["createAutocompleteState.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAA;AAMtD,MAAM,WAAW,iBAAiB;IAChC,mDAAmD;IACnD,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;IAC5B,gDAAgD;IAChD,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,6EAA6E;IAC7E,aAAa,EAAE,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IACtC,kFAAkF;IAClF,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAA;CAC7C;AAED,MAAM,WAAW,wBAAwB;IACvC,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,kEAAkE;IAClE,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,wEAAwE;IACxE,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CACxC;AAMD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,GAAE,wBAA6B,GACnC,iBAAiB,CA+BnB"}

package/src/autocomplete/index.d.ts

@@ -1,6 +0,0 @@
-export {
-  createAutocompleteState,
-  type AutocompleteState,
-  type AutocompleteStateOptions,
-} from "./createAutocompleteState";
-//# sourceMappingURL=index.d.ts.map

package/src/autocomplete/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,GAC9B,MAAM,2BAA2B,CAAA"}