rexfect 0.0.7

package/dist/types.d.ts

@@ -0,0 +1,606 @@
+/**
+ * Generic function type for any function signature.
+ * Used internally for type constraints.
+ */
+export type AnyFunc = (...args: any[]) => any;
+/**
+ * A reactive signal that holds a value.
+ *
+ * Signals are the read-only part of atoms. They:
+ * - Return current value when called as a function
+ * - Auto-track dependencies when read inside effect() or useRx()
+ * - Allow subscription to changes via .on()
+ *
+ * @template T - The type of value the signal holds
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = atom(0);
+ * // count is Signal<number>
+ *
+ * count();        // Read: 0
+ * count.on(v => console.log(v)); // Subscribe
+ * ```
+ */
+export type Signal<T = any> = {
+    /**
+     * Get current value.
+     * When called inside effect() or useRx(), creates a dependency -
+     * the effect/component will re-run when this signal changes.
+     */
+    (): T;
+    /**
+     * Subscribe to value changes.
+     * @param listener - Called with new value whenever signal changes
+     * @returns Unsubscribe function - call to stop receiving updates
+     */
+    on(listener: (value: T) => void): VoidFunction;
+};
+/**
+ * A setter function for updating atom value.
+ *
+ * @template T - The type of value to set
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = atom(0);
+ * setCount(5);           // Set to 5
+ * setCount(c => c + 1);  // Functional update (if supported)
+ * ```
+ */
+export type Setter<T = any> = (value: T) => void;
+/**
+ * A getter function that returns a value.
+ * Used for read-only access patterns.
+ *
+ * @template T - The type of value returned
+ */
+export type Getter<T = any> = () => T;
+/**
+ * Tuple type returned by atom() - [getter, setter] pair.
+ * Similar to React's useState return type.
+ *
+ * @template T - The type of value in the atom
+ */
+export type Tuple<T = any> = readonly [getter: Getter<T>, setter: Setter<T>];
+/**
+ * Mapper function that transforms a source signal into a destination signal.
+ * Used for signal-only transformations in atom.use().
+ *
+ * @template S - Source signal type
+ * @template D - Destination signal type
+ *
+ * @example
+ * ```ts
+ * const mapper: SignalMapper<Signal<number>, Signal<string>> = (s) => () => s().toString();
+ * ```
+ */
+export type SignalMapper<S extends Signal<any>, D extends Signal<any>> = (origin: S) => D;
+/**
+ * Mapper function that transforms a source setter into a destination setter.
+ * Used for setter-only transformations in atom.use().
+ *
+ * @template S - Source setter type
+ * @template D - Destination setter type
+ *
+ * @example
+ * ```ts
+ * const mapper: SetterMapper<Setter<{a: number}>, Setter<string>> =
+ *   (set) => (value: string) => set({ a: Number(value) });
+ * ```
+ */
+export type SetterMapper<S extends Setter<any>, D extends Setter<any>> = (origin: S) => D;
+/**
+ * Options for atom.use() transformations.
+ * Supports three patterns:
+ * 1. Setter-only: Pass a SetterMapper function directly
+ * 2. Signal + Setter: Pass object with `sig` and optional `set` properties
+ * 3. Signal-only: Pass object with only `sig` property
+ *
+ * @template TSignal - Original signal type
+ * @template TSetter - Original setter type
+ * @template TNewSignal - New signal type (defaults to TSignal)
+ * @template TNewSetter - New setter type (defaults to TSetter)
+ *
+ * @example
+ * ```ts
+ * // Setter-only transformation
+ * atom({a: 0}).use((set) => (value: string) => set({ a: Number(value) }));
+ *
+ * // Signal + setter transformation
+ * atom({a: 0, b: 0}).use({
+ *   sig: (s) => () => s().a,
+ *   set: (set) => (value: number) => set({ a: value, b: 0 })
+ * });
+ *
+ * // Signal-only transformation
+ * atom({a: 0}).use({
+ *   sig: (s) => () => s().a
+ * });
+ * ```
+ */
+export type UseOptions<TSignal extends Signal<any>, TSetter extends Setter<any>, TNewSignal extends Signal<any> = TSignal, TNewSetter extends Setter<any> = TSetter> = SetterMapper<TSetter, TNewSetter> | {
+    sig: SignalMapper<TSignal, TNewSignal>;
+    set?: SetterMapper<TSetter, TNewSetter>;
+};
+/**
+ * Adds .use() method to a tuple of [Signal, Setter].
+ * The tuple remains destructureable while gaining transformation capabilities.
+ *
+ * @template T - Tuple type [Signal<any>, Setter<any>]
+ *
+ * @example
+ * ```ts
+ * const mappable: WithUse<[Signal<number>, Setter<number>]> = withUse([s, set]);
+ * const [s, set] = mappable; // Still destructureable
+ * const transformed = mappable.use((setter, signal) => ({ set: (v: string) => setter(Number(v)) })); // Chainable
+ * ```
+ */
+export type WithUse<T extends readonly [Signal<any>, Setter<any>]> = {
+    /**
+     * Apply a plugin to the atom's signal and/or setter.
+     * Plugins can transform types, add listeners, or enhance behavior.
+     * Returns a new withUse tuple that can be chained further.
+     *
+     * @param plugin - Plugin function that receives setter and signal and returns an object with optional sig and set properties, or void for side effects only
+     * @returns New withUse tuple with potentially modified signal/setter
+     */
+    use<TNewSignal extends Signal<any> = T[0], TNewSetter extends Setter<any> = T[1]>(plugin: (signal: T[0], setter: T[1]) => {
+        sig?: TNewSignal;
+        set?: TNewSetter;
+    } | void): WithUse<readonly [TNewSignal, TNewSetter]>;
+} & T;
+/**
+ * A mappable atom - a tuple of [Signal, Setter] with .use() method for transformations.
+ * Can be destructured normally or used with .use() for chaining transformations.
+ *
+ * @template T - The type of value stored in the atom
+ *
+ * @example
+ * ```ts
+ * const atomValue: Atom<number> = atom(1);
+ * const [signal, setter] = atomValue; // Destructureable
+ * const transformed = atomValue.use((set, sig) => [sig, (v: string) => set(Number(v))]); // Chainable
+ * ```
+ */
+export type Atom<T> = WithUse<readonly [Signal<T>, Setter<T>]>;
+/**
+ * Options for creating an atom.
+ *
+ * @template T - The type of value the atom holds
+ *
+ * @example
+ * ```ts
+ * const [user, setUser] = atom(userData, {
+ *   equals: "shallow",  // Only notify if properties changed
+ *   key: "currentUser", // For debugging
+ * });
+ * ```
+ */
+export interface AtomOptions<T> {
+    /**
+     * Equality function to determine if value has changed.
+     * If values are "equal", subscribers won't be notified.
+     *
+     * - `"strict"` (default): Object.is comparison
+     * - `"shallow"`: Compare object keys/array length, Object.is per item
+     * - `"shallow2"`: 2 levels deep
+     * - `"shallow3"`: 3 levels deep
+     * - `"deep"`: Full recursive comparison
+     * - `(a, b) => boolean`: Custom comparison function
+     */
+    equals?: Equality<T>;
+    /**
+     * Debug key for identifying this atom in dev tools or logs.
+     */
+    key?: string;
+}
+/**
+ * Options for creating an action.
+ *
+ * @example
+ * ```ts
+ * const onAppInit = action<Config>({
+ *   sealed: true, // Only fires once
+ *   key: "appInit",
+ * });
+ * ```
+ */
+export interface ActionOptions {
+    /**
+     * Debug key for identifying this action in dev tools or logs.
+     */
+    key?: string;
+    /**
+     * If true, action "seals" after first dispatch:
+     * - Subsequent dispatches become no-ops (listeners don't fire)
+     * - Late subscribers receive the last payload immediately
+     *
+     * Useful for one-time initialization patterns.
+     */
+    sealed?: boolean;
+}
+/**
+ * Options for effect().
+ */
+export interface EffectOptions {
+    /**
+     * Debug key for identifying this effect in dev tools or logs.
+     */
+    key?: string;
+}
+/**
+ * Base context with plugin system.
+ *
+ * The `use()` method allows extending context functionality via plugins.
+ * Plugins receive the context and can return additional utilities.
+ *
+ * @example
+ * ```ts
+ * const withRetry = (ctx, maxRetries) => ({
+ *   async fetch(url) {
+ *     for (let i = 0; i < maxRetries; i++) {
+ *       try { return await fetch(url, { signal: ctx.signal }); }
+ *       catch (e) { if (i === maxRetries - 1) throw e; }
+ *     }
+ *   }
+ * });
+ *
+ * action.on((payload, ctx) => {
+ *   const { fetch } = ctx.use(withRetry, 3);
+ *   await fetch('/api/data');
+ * });
+ * ```
+ */
+export interface UsableContext {
+    /**
+     * Apply a plugin to extend context functionality.
+     *
+     * @param fn - Plugin function that receives context and returns utilities
+     * @param args - Additional arguments passed to the plugin
+     * @returns Whatever the plugin returns
+     */
+    use<R, Args extends any[]>(fn: (context: this, ...args: Args) => R, ...args: Args): R;
+}
+/**
+ * Context with abort/cancellation capabilities.
+ *
+ * Provides utilities for cancelling async operations:
+ * - `signal` for passing to fetch, AbortController-aware APIs
+ * - `safe()` for ignoring results after abort
+ * - `abortPrev()` for cancelling previous invocation (latest-only pattern)
+ * - `fork()`/`spawn()` for child contexts
+ *
+ * @example
+ * ```ts
+ * async function fetchData(ctx: AbortableContext) {
+ *   const res = await fetch('/api', { signal: ctx.signal });
+ *   return ctx.safe(res.json()); // Ignored if aborted
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Latest-only pattern with abortPrev
+ * const search = abortable(async ({ signal, abortPrev }, query: string) => {
+ *   abortPrev(); // Cancel previous search
+ *   const res = await fetch(`/search?q=${query}`, { signal });
+ *   return res.json();
+ * });
+ * ```
+ */
+export interface AbortableContext extends UsableContext {
+    /**
+     * AbortSignal for this context.
+     * Pass to fetch, axios, or any AbortController-aware API.
+     * Becomes aborted when abort() is called.
+     */
+    signal: AbortSignal;
+    /**
+     * Abort this context.
+     * Sets signal.aborted to true and triggers abort event.
+     */
+    abort(): void;
+    /**
+     * Abort the previous invocation of this abortable function.
+     * Useful for "latest only" patterns where rapid calls should cancel in-flight operations.
+     *
+     * @param message - Optional abort message
+     *
+     * @example
+     * ```ts
+     * const search = abortable(async ({ signal, abortPrev }, query: string) => {
+     *   abortPrev(); // Cancel previous search
+     *   const res = await fetch(`/search?q=${query}`, { signal });
+     *   return res.json();
+     * });
+     *
+     * search("h");
+     * search("he");
+     * const results = await search("hello"); // Only this completes
+     * ```
+     */
+    abortPrev(message?: string): void;
+    /**
+     * Wrap a promise to ignore its result if context is aborted.
+     * If aborted, returns a promise that never resolves/rejects.
+     *
+     * @param promise - Promise to wrap
+     * @returns Promise that ignores result if aborted
+     */
+    safe<T>(promise: PromiseLike<T>): Promise<T>;
+    /**
+     * Wrap a callback to no-op if context is aborted.
+     * Useful for setTimeout/setInterval callbacks.
+     *
+     * @param callback - Function to wrap
+     * @returns Function that no-ops if aborted
+     */
+    safe<A extends any[]>(callback: (...args: A) => void): (...args: A) => void;
+    /**
+     * Create a child context that aborts when this context aborts.
+     * Useful for sub-operations that should cancel with parent.
+     */
+    fork(): AbortableContext;
+    /**
+     * Create an independent context that doesn't abort with parent.
+     * Useful for background operations that should continue.
+     */
+    spawn(): AbortableContext;
+}
+/**
+ * Context passed to effect callbacks.
+ *
+ * Provides lifecycle utilities and run information.
+ *
+ * @example
+ * ```ts
+ * effect((ctx) => {
+ *   if (ctx.nth === 0) return; // Skip first run
+ *
+ *   ctx.onError((err) => console.error(err));
+ *
+ *   const interval = setInterval(tick, 1000);
+ *   ctx.onCleanup(() => clearInterval(interval));
+ * });
+ * ```
+ */
+export interface EffectContext extends UsableContext {
+    /**
+     * How many times this effect has run.
+     * - 0 on first run
+     * - 1 on second run
+     * - etc.
+     *
+     * Useful for skipping logic on initial run:
+     * ```ts
+     * if (ctx.nth === 0) return; // Skip initialization
+     * ```
+     */
+    nth: number;
+    /**
+     * Effect key from options, for debugging.
+     */
+    key: string | undefined;
+    /**
+     * Register an error handler for this effect run.
+     * If registered, errors are caught and passed to handler
+     * instead of propagating up.
+     *
+     * @param handler - Called with error if effect throws
+     */
+    onError(handler: (error: unknown) => void): void;
+    /**
+     * Register a cleanup function to run before next effect run.
+     * Useful for cleaning up subscriptions, timers, etc.
+     *
+     * Note: Does NOT run on dispose, only before re-runs.
+     *
+     * @param cleanup - Function to call for cleanup
+     */
+    onCleanup(cleanup: VoidFunction): void;
+}
+/**
+ * @deprecated ActionContext removed - handlers are now simple functions.
+ * For lifecycle features (cancellation, error handling), use abortable wrapper.
+ *
+ * @example
+ * ```ts
+ * // Simple action
+ * const search = action(async (query: string) => {
+ *   return fetch(`/search?q=${query}`).then(r => r.json());
+ * });
+ *
+ * // With cancellation - wrap in abortable
+ * const searchAbortable = abortable(async ({ signal, abort }, query: string) => {
+ *   abort(); // Cancel previous
+ *   const res = await fetch(`/search?q=${query}`, { signal });
+ *   return res.json();
+ * });
+ * const search = action((query: string) => searchAbortable(query));
+ * ```
+ */
+export interface ActionContext {
+}
+/**
+ * @deprecated OnContext removed - listeners are now simple functions.
+ * For lifecycle features, wrap listener logic in abortable.
+ */
+export interface OnContext {
+}
+/**
+ * Action type - callable dispatcher with subscription methods.
+ *
+ * Actions are the core primitive for dispatching and handling events/commands.
+ *
+ * **Two patterns:**
+ * - `Action<T, void>` — Void action for notifications (use "on" prefix: `onClick`)
+ * - `Action<T, R>` — Action with handler that returns R (use verbs: `addToCart`)
+ *
+ * **Key features:**
+ * - Callable: `action(payload)` dispatches and returns result
+ * - Thenable: `await action` waits for next dispatch
+ * - Subscribable: `action.on(listener)` registers listeners
+ * - Sealable: `{ sealed: true }` for one-time initialization
+ *
+ * @template T - Payload type
+ * @template R - Return type (void for void actions)
+ *
+ * @example
+ * ```ts
+ * // Void action (notification)
+ * const onClick = action<MouseEvent>();
+ * onClick.on((e) => console.log(e.clientX));
+ * onClick(event); // → void
+ *
+ * // Action with handler (command)
+ * const addToCart = action((item: Item) => {
+ *   setCart([...cart(), item]);
+ *   return cart().length;
+ * });
+ * const count = addToCart(item); // → number
+ *
+ * // With cancellation - wrap in abortable
+ * const searchAbortable = abortable(async ({ signal, abort }, query: string) => {
+ *   abort(); // Cancel previous
+ *   const res = await fetch(`/search?q=${query}`, { signal });
+ *   return res.json();
+ * });
+ * const search = action((query: string) => searchAbortable(query));
+ * ```
+ */
+export type Action<T, R = void> = {
+    /**
+     * Dispatch the action with payload.
+     * Executes handler (if any), notifies listeners, returns result.
+     *
+     * @param payload - Data to dispatch
+     * @returns Handler result (undefined for void actions)
+     */
+    (payload: T): R;
+    /**
+     * Check if action is sealed (no more listener notifications).
+     * Actions with `{ sealed: true }` seal after first dispatch.
+     */
+    sealed(): boolean;
+    /**
+     * Check if action has been dispatched at least once.
+     */
+    fired(): boolean;
+    /**
+     * Get last dispatched payload, or wait for next dispatch.
+     * Unlike `await action` (always waits for NEXT), this returns
+     * immediately if already fired.
+     */
+    latest(): Promise<T>;
+    /**
+     * Subscribe a listener to this action.
+     *
+     * Listener receives payload on each dispatch.
+     * For sealed actions, late subscribers fire immediately with last payload.
+     *
+     * @param listener - Called on each dispatch with payload
+     * @returns Unsubscribe function
+     */
+    on(listener: (payload: T) => void | Promise<void>): VoidFunction;
+    /**
+     * Make action thenable (PromiseLike).
+     * Enables `await action` to wait for next dispatch.
+     *
+     * Note: Always waits for NEXT dispatch, even if already fired.
+     * Use `.latest()` to get current value if available.
+     */
+    then<R1 = T, R2 = never>(onFulfilled?: ((value: T) => R1 | PromiseLike<R1>) | null, onRejected?: ((reason: any) => R2 | PromiseLike<R2>) | null): Promise<R1 | R2>;
+    /**
+     * Dispose the action, clearing all listeners and state.
+     * After dispose, dispatches still work but listeners don't fire.
+     */
+    dispose(): void;
+    as<NewR extends R = R, NewT extends T = T>(): Action<NewT, NewR>;
+};
+/**
+ * Result of a loadable operation - represents async state.
+ *
+ * Used by `loadable()` to extract loading/data/error from promises.
+ *
+ * @template T - The type of resolved data
+ *
+ * @example
+ * ```ts
+ * const state = loadable(userPromise);
+ * if (state?.loading) return <Spinner />;
+ * if (state?.error) return <Error error={state.error} />;
+ * return <User data={state.data} />;
+ * ```
+ */
+export type LoadableResult<T> = {
+    /** True while promise is pending */
+    loading: boolean;
+    /** Resolved value (undefined while loading or on error) */
+    data: T | undefined;
+    /** Rejection reason (undefined while loading or on success) */
+    error: unknown | undefined;
+};
+/**
+ * Extracts the resolved type from a Promise type.
+ * `PromiseValue<Promise<string>>` → `string`
+ */
+export type PromiseValue<T> = T extends Promise<infer U> ? U : never;
+/**
+ * Type utility to check if T includes null or undefined.
+ * Used for conditional return types in loadable().
+ */
+export type IncludesNullish<T> = null extends T ? true : undefined extends T ? true : false;
+/**
+ * Return type of loadable() - accounts for nullish signal values.
+ * If signal can be null/undefined, return type includes null.
+ */
+export type LoadableReturn<TValue> = IncludesNullish<TValue> extends true ? LoadableResult<PromiseValue<NonNullable<TValue>>> | null : LoadableResult<PromiseValue<TValue>>;
+/**
+ * Simple listener callback type.
+ * @template T - Value type passed to listener
+ */
+export type Listener<T> = (value: T) => void;
+/**
+ * Flexible listener specification for emitter.
+ * Can be:
+ * - Single listener function
+ * - Array of listener functions
+ * - Factory function returning listener(s)
+ *
+ * @template T - Value type passed to listeners
+ */
+export type SingleOrMultipleListeners<T> = Listener<T> | Listener<T>[] | ((value: T) => Listener<T> | Listener<T>[] | undefined);
+/**
+ * Built-in equality strategy names.
+ *
+ * Used with atoms to control when subscribers are notified:
+ * - `"strict"` - Object.is (default, fastest)
+ * - `"shallow"` - Compare object keys/array items with Object.is
+ * - `"shallow2"` - 2 levels deep
+ * - `"shallow3"` - 3 levels deep
+ * - `"deep"` - Full recursive comparison (slowest)
+ */
+export type EqualityShorthand = "strict" | "shallow" | "shallow2" | "shallow3" | "deep";
+/**
+ * Equality strategy for change detection.
+ *
+ * Can be a shorthand string or custom comparison function.
+ * Used by atoms to determine if value has "changed" -
+ * if equal, subscribers won't be notified.
+ *
+ * @template T - Type of values being compared
+ *
+ * @example
+ * ```ts
+ * // Using shorthand
+ * const [user, setUser] = atom(data, { equals: "shallow" });
+ *
+ * // Using custom function
+ * const [user, setUser] = atom(data, {
+ *   equals: (a, b) => a.id === b.id
+ * });
+ * ```
+ */
+export type Equality<T = unknown> = EqualityShorthand | ((a: T, b: T) => boolean);
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,5 @@
+// ============================================================================
+// Core Types
+// ============================================================================
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,aAAa;AACb,+EAA+E"}

package/dist/untrack.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Reads reactive values without creating dependencies.
+ *
+ * @param fn - Function that reads reactive values
+ * @returns The return value of the function
+ *
+ * @example
+ * effect(() => {
+ *   const a = count(); // tracked
+ *   const b = untrack(() => name()); // not tracked
+ * });
+ */
+export declare function untrack<T>(fn: () => T): T;
+//# sourceMappingURL=untrack.d.ts.map

package/dist/untrack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"untrack.d.ts","sourceRoot":"","sources":["../src/untrack.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAEzC"}

package/dist/untrack.js

@@ -0,0 +1,17 @@
+import { withHooks } from "./hooks";
+/**
+ * Reads reactive values without creating dependencies.
+ *
+ * @param fn - Function that reads reactive values
+ * @returns The return value of the function
+ *
+ * @example
+ * effect(() => {
+ *   const a = count(); // tracked
+ *   const b = untrack(() => name()); // not tracked
+ * });
+ */
+export function untrack(fn) {
+    return withHooks({ track: undefined }, fn);
+}
+//# sourceMappingURL=untrack.js.map

package/dist/untrack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"untrack.js","sourceRoot":"","sources":["../src/untrack.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEpC;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,OAAO,CAAI,EAAW;IACpC,OAAO,SAAS,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC;AAC7C,CAAC"}

package/dist/utils/withUse.d.ts

@@ -0,0 +1,10 @@
+import type { Signal, Setter, WithUse } from "../types";
+/**
+ * Creates a mappable tuple by adding .use() method to the tuple.
+ * The tuple can still be destructured normally: const [signal, setter] = withUse([s, set])
+ *
+ * @param tuple - The tuple [Signal, Setter] to make mappable
+ * @returns The same tuple with .use() method attached
+ */
+export declare function withUse<T extends readonly [Signal<any>, Setter<any>]>(tuple: T): WithUse<T>;
+//# sourceMappingURL=withUse.d.ts.map

package/dist/utils/withUse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withUse.d.ts","sourceRoot":"","sources":["../../src/utils/withUse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAExD;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,EACnE,KAAK,EAAE,CAAC,GACP,OAAO,CAAC,CAAC,CAAC,CAmBZ"}