@raphy-js/raph 1.0.1-dev.20 → 1.0.1-dev.26

package/dist/runtime/ownership/RaphNode.d.ts

@@ -1,3 +1,4 @@
+import { DisposalFailure } from '../../reactivity/disposal';
 import { RaphRuntime } from '../RaphRuntime';
 import { RaphScope } from './RaphScope';
 export interface NodeOptions {
@@ -7,34 +8,303 @@ export interface NodeOptions {
     readonly meta?: Readonly<Record<string, unknown>>;
     readonly type?: string;
 }
+/**
+ * Запись, которая знает свою node: сама RaphNode либо объект потребителя с
+ * полем `node`. Позволяет передать на удаление уже существующий массив записей
+ * без копии в массив nodes.
+ */
+export interface RaphNodeHolder {
+    readonly node: RaphNode;
+}
 /** Scope with an explicit parent/children ownership position. */
 export declare class RaphNode<TApi = unknown> extends RaphScope {
+    #private;
     priority: number;
     private _parent;
-    private readonly _children;
+    private _prevSibling;
+    private _nextSibling;
+    private _firstChild;
+    private _lastChild;
+    /**
+     * Число прямых детей. Structural owner читает его, чтобы узнать состав
+     * списка, не строя массив `children`; изменяет поле только сама node.
+     *
+     * @internal
+     */
+    _childCount: number;
+    private _childArray;
     private _published;
-    readonly api: Readonly<TApi>;
-    meta: Record<string, unknown>;
+    private _meta;
     type: string;
-    /** Distinguishes a subtree granule from the node's self granule. @internal */
-    readonly _subtreeSourceIdentity: Readonly<{}>;
+    private _subtreeIdentity;
     constructor(parent: RaphNode | RaphRuntime | null, options?: Omit<NodeOptions, 'parent'>, runtime?: RaphRuntime, publication?: never);
+    /**
+     * Возвращает id; номер id по умолчанию превращается в `node-N` при первом чтении.
+     */
+    get id(): string;
+    /**
+     * Возвращает изменяемую metadata node; объект создаётся при первом чтении.
+     */
+    get meta(): Record<string, unknown>;
+    set meta(value: Record<string, unknown>);
+    /**
+     * Возвращает api, зафиксированный после setup; присваивание снаружи запрещено.
+     */
+    get api(): Readonly<TApi>;
+    /**
+     * Отличает subtree granule от self granule; identity создаётся по запросу.
+     * @internal
+     */
+    get _subtreeSourceIdentity(): object;
     get node(): RaphNode<TApi>;
     get parent(): RaphNode | null;
+    /**
+     * Возвращает прямых детей в их порядке. Массив действителен до следующей
+     * структурной mutation этой node; после неё порядок даёт новое чтение.
+     *
+     * Добавление в конец, удаление последнего child и `reorderChildren`
+     * обновляют уже выданный массив на месте. После удаления любого другого
+     * child — первого или из середины — выданный массив либо остаётся прежним, и
+     * следующее чтение строит новый, либо обновляется на месте — второе
+     * происходит, пока у Runtime есть подписчик на node.
+     *
+     * `moveChild` и `_swapChildren` следуют тому же правилу, что и удаление не
+     * последнего child: без подписчика на node выданный массив остаётся прежним,
+     * с подписчиком получает новый порядок на месте. `_disposeChildren` забывает
+     * выданный массив, если набор начинается с первого child списка: массив
+     * хранит состав на начало удаления. Набор, который начинается с другого
+     * child, следует правилу отдельных удалений.
+     *
+     * Собственный dispose node выданный массив не обновляет: пока node удаляет
+     * своих детей, он хранит их состав на начало удаления, а после удаления
+     * последнего child становится пустым. Оставшихся детей в это время даёт
+     * новое чтение; выданный им массив остаётся массивом node до конца удаления:
+     * дети выходят из него на месте и при отсутствии подписчика на node, а после
+     * последнего child он тоже пуст.
+     */
     get children(): readonly RaphNode[];
     addChild(node: RaphNode): boolean;
+    /**
+     * Ставит прямых детей в порядок `nodes`: в нём каждый прямой child ровно
+     * один раз. Без подписчика на node порядок проверяется и применяется по
+     * связям между siblings, без Set и Map.
+     *
+     * Каждый элемент `nodes` читается один раз, до проверки. Чтение, которое само
+     * меняет дерево — элемент Proxy либо accessor, — не оставляет списки в
+     * промежуточном состоянии: порядок проверяется по составу детей после чтения.
+     */
     reorderChildren(nodes: readonly RaphNode[]): void;
+    /**
+     * Ставит прямого child перед прямым child `before` либо в конец списка, если
+     * `before === null`. Без подписчика на node меняются только связи самого
+     * child и его соседей: цена не зависит от числа детей. С подписчиком каждый
+     * child, чей индекс изменился, получает тот же structure cause, что и после
+     * `reorderChildren` с итоговым порядком.
+     */
+    moveChild(child: RaphNode, before: RaphNode | null): void;
+    /**
+     * Меняет местами двух прямых детей. Без подписчика на node правятся только
+     * связи этих детей и их соседей; с подписчиком оба child получают те же
+     * structure causes, что и после `reorderChildren` с итоговым порядком.
+     *
+     * @internal
+     */
+    _swapChildren(first: RaphNode, second: RaphNode): void;
+    /**
+     * Удаляет детей одной границей удаления и возвращает их ошибки вместо throw.
+     *
+     * Без аргументов удаляются все дети node, какими они были на момент вызова.
+     * С `holders` удаляются nodes записей `holders[start]`…`holders[end - 1]`:
+     * ожидается, что это прямые дети node. Массив записей служит snapshot набора
+     * и не копируется: child, которого cleanup более раннего child уже удалил,
+     * пропускается, перенесённый к другому parent всё равно удаляется, а дети,
+     * добавленные во время удаления, в набор не входят.
+     *
+     * Каждый child удаляется собственным `dispose()` в порядке набора: порядок
+     * cleanup, structure causes при наличии подписчика и ошибка каждого child те
+     * же, что у отдельных вызовов `dispose()` внутри одного batch. Ошибка child
+     * не прерывает удаление остальных; ошибки возвращаются в порядке набора,
+     * последней — ошибка phases, исполненных при закрытии границы.
+     *
+     * Граница одна на весь набор: phases, запрошенные cleanup, исполняются после
+     * последнего child, а не между детьми. Это граница удаления владельца, как у
+     * `RaphNode.dispose()`, а не reactive batch: запись signal из cleanup
+     * применяется сразу, и её phase tasks встают в очередь в момент записи, в
+     * порядке отдельных удалений. Внутри `batch` та же запись откладывается до
+     * его конца, поэтому порядок phase tasks у batch другой.
+     *
+     * Выданный массив `children` node забывает до первого child, если набор
+     * начинается с первого child списка либо набором передан сам этот массив: он
+     * остаётся у того, кто его держит, с составом на начало удаления, и удаление
+     * набора от первого child списка не правит его через `shift`, `splice` или
+     * `indexOf` даже при подписчике на node. Набор, который начинается с другого
+     * child, следует правилу отдельных `dispose()`: последний child уходит из
+     * массива через pop, остальные вырезаются на месте при подписчике на node, а
+     * без подписчика массив забывается первым же удалением.
+     *
+     * @internal
+     */
+    _disposeChildren(): unknown[] | undefined;
+    /** @internal */
+    _disposeChildren(holders: readonly RaphNodeHolder[], start?: number, end?: number): unknown[] | undefined;
     options(options: Pick<NodeOptions, 'meta' | 'priority' | 'type'>): void;
     /** Invalidates coarse self/subtree/runtime granules for non-reactive state. */
     touch(metadata?: unknown): void;
     remove(): void;
     dispose(): void;
-    /** @internal */
+    /** Calls actual public dispatch once; only native disposal can return provenance. @internal */
+    _disposeForOwner(): DisposalFailure | undefined;
+    /** Result of this exact framework call, without changing raw public disposal. @internal */
+    _disposeWithOutcome(): DisposalFailure | undefined;
+    /**
+     * Фиксирует api после setup; object api замораживается, как и раньше.
+     * Исключение — Runtime signal, возвращённый как api: значение, запись графа
+     * и связи подписчиков лежат в его собственных полях, поэтому заморозка
+     * лишила бы его записи, отслеживаемого чтения, watch и освобождения вместе
+     * с владельцем.
+     * @internal
+     */
     _setApi(api: TApi): void;
     /** Publishes a fully initialized provisional subtree. @internal */
     _publishCreation(): void;
     /** @internal */
     _isPublished(): boolean;
+    /**
+     * Сообщает, стоит ли node в списке детей своего parent. Node без parent и
+     * node, чей parent уже сбросил свой список, в нём не стоят.
+     *
+     * @internal
+     */
+    _isLinked(): boolean;
+    /**
+     * Добавляет в `into` всех потомков node по связям списков детей: каждый
+     * child сразу за своим parent, дети — в порядке списка. Обход не строит
+     * массивы `children` и не зависит от глубины стека.
+     *
+     * @internal
+     */
+    _collectDescendants(into: RaphScope[]): void;
+    /**
+     * Прибавляет к `totals` число ресурсов и sources самой node и всех её
+     * потомков. Обход тот же, что у `_collectDescendants`, но владельцев он не
+     * собирает: подсчёт для diagnostics не выделяет память по числу владельцев.
+     *
+     * @internal
+     */
+    _countSubtree(totals: {
+        resources: number;
+        sources: number;
+    }): void;
+    /**
+     * Ищет node по id в своём поддереве. Порядок обхода прежний: сама node,
+     * затем дети от последнего к первому, каждый вместе со своим поддеревом.
+     *
+     * @internal
+     */
+    _findNode(id: string): RaphNode | undefined;
+    /**
+     * Применяет порядок детей `nodes`. Возвращает `false` и оставляет список
+     * прежним, если `nodes` не содержит каждого живого прямого child ровно один
+     * раз. Прежние индексы собираются только при подписчике на node: без него
+     * structure cause никто не получит.
+     */
+    private _applyChildOrder;
+    /**
+     * Проверяет порядок и переставляет связи за три прохода без Set и Map.
+     * Сначала каждый child списка получает метку: его `_prevSibling` указывает на
+     * parent, чего у прямого child не бывает. Затем метка снимается у каждой node
+     * из `nodes`: node без метки — чужая, удаляемая либо повторная. При отказе
+     * и при ошибке чтения `nodes` связи `_prevSibling` восстанавливаются по
+     * нетронутым `_nextSibling`.
+     *
+     * `nodes` — собственная копия порядка: её чтение не исполняет чужой код, и
+     * между расстановкой меток и их снятием дерево никто не меняет.
+     */
+    private _relinkChildren;
+    /**
+     * Сообщает причину отказа порядка `nodes` теми же ошибками и в том же
+     * порядке, что и прежняя проверка; Set нужен только здесь.
+     */
+    private _rejectChildOrder;
+    /**
+     * Запоминает индекс каждого child до перестановки; нужен только для
+     * structure causes.
+     */
+    private _indexChildren;
+    /**
+     * Завершает перестановку связей при подписчике на node: массив детей
+     * получает новый порядок на месте либо строится, и каждый child со
+     * сменившимся индексом получает structure cause.
+     */
+    private _publishChildOrder;
+    /**
+     * Публикует structure cause каждому child, чей индекс изменился, в новом
+     * порядке детей и одной границей mutation.
+     */
+    private _notifyChildOrder;
+    /**
+     * Переставляет child перед `before` либо в конец списка, меняя только связи
+     * child и его соседей. Вызывающий гарантирует, что оба — дети этой node и
+     * что child ещё не стоит перед `before`.
+     */
+    private _relinkBefore;
+    /**
+     * Строит массив детей по связям и запоминает его для следующих чтений.
+     */
+    private _materializeChildren;
+    /**
+     * Собирает детей по связям в новый массив, не запоминая его.
+     */
+    private _collectChildren;
+    /**
+     * Очищает и забывает выданный массив детей, если он есть.
+     */
+    private _clearChildArray;
+    /**
+     * Добавляет child в конец списка; уже выданный массив получает его через push.
+     */
+    private _appendChild;
+    /**
+     * Возвращает позицию node среди детей `parent` либо -1, если `parent` уже
+     * сбросил свой список и node в нём не состоит. Нужна только для structure
+     * cause. Первый и последний child определяются по связям, остальные — через
+     * `indexOf` по массиву детей, как и раньше; массив строится один раз и затем
+     * поддерживается, поэтому обход связей на каждый запрос не повторяется.
+     */
+    private _indexIn;
+    /**
+     * Вынимает node из списка `parent` и обнуляет её связи, чтобы удержанная node
+     * не удерживала соседей. Связи правятся за постоянное время.
+     *
+     * Уже выданный массив теряет последний child через pop. Любой другой child —
+     * первый или из середины — вырезается на месте, только если его `index`
+     * известен (>= 0) либо у Runtime есть подписчик на node: тогда массив ещё
+     * понадобится для индексов и перестраивать его по связям после каждого
+     * удаления дороже. Иначе массив не правится, а отбрасывается, и следующее
+     * чтение `children` строит новый: очистка списка от первого child к
+     * последнему не сдвигает массив на каждое удаление.
+     *
+     * Пока parent удаляет собственных детей, массив не отбрасывается: его мог
+     * запросить только cleanup уже удаляемого child, и `_resetChildList` обязан
+     * очистить именно его. Отброшенный массив остался бы у cleanup с удалёнными
+     * детьми внутри.
+     */
+    private _unlinkFrom;
+    /**
+     * Возвращает snapshot детей для их удаления. Уже выданный массив
+     * переиспользуется без копии и на время удаления перестаёт быть массивом
+     * node: дети выходят из списка только через связи, snapshot не сдвигается, и
+     * удаление не платит за `shift` на каждого child. Иначе snapshot строится по
+     * связям.
+     */
+    private _takeChildSnapshot;
+    /**
+     * Сбрасывает собственный список после удаления детей. `snapshot` мог быть
+     * выданным массивом: как и раньше, у удалённой node он остаётся пустым.
+     * Массив, запрошенный во время удаления, очищается так же: `_unlinkFrom` не
+     * отбрасывает его, пока node удаляет своих детей.
+     */
+    private _resetChildList;
 }
 /** Creates an unpublished node that Runtime.node() commits after setup. @internal */
 export declare function createProvisionalNode<TApi>(parent: RaphNode, options: Omit<NodeOptions, 'parent'>, runtime: RaphRuntime): RaphNode<TApi>;

package/dist/runtime/ownership/RaphScope.d.ts

@@ -1,38 +1,168 @@
-import { Disposer, OwnedSource, ReadonlySignal, Signal, WritableComputedOptions } from '../../reactivity/types';
-import { RaphAggregateSource, RaphEffectOptions, RaphPhaseEffect, RaphWatchOptions, RaphWatchSource } from '../phases/phase.types';
+import { DisposalFailure } from '../../reactivity/disposal';
+import { OwnedSourceEntry, ScopeOwner } from '../../reactivity/scope';
+import { Disposer, OwnedResource, OwnedSource, ReadonlySignal, Signal, WritableComputedOptions } from '../../reactivity/types';
+import { RaphAggregateSource, RaphEffectGroup, RaphEffectGroupOptions, RaphEffectGroupSlot, RaphEffectOptions, RaphPhaseBody, RaphPhaseEffect, RaphWatchOptions, RaphWatchSource } from '../phases/phase.types';
 import { RaphRuntime } from '../RaphRuntime';
+import { RaphSelector, RaphSelectorOptions } from '../reactivity/RaphSelector';
 import { RaphAggregate } from '../reactivity/RaphWorkGraph';
 import { RaphNode } from './RaphNode';
-/** Runtime owner storage intentionally does not inherit standalone unphased effect/watch. */
-export declare class RaphScope {
-    readonly id: string;
+/**
+ * Runtime owner. Список ресурсов, список источников и признаки lifetime
+ * наследуются от ScopeOwner и лежат в самом владельце; standalone unphased
+ * effect/watch класса ScopeNode Runtime-владелец намеренно не наследует.
+ */
+export declare class RaphScope extends ScopeOwner {
+    /**
+     * Явный id либо числовой номер id по умолчанию, который RaphNode
+     * форматирует при первом чтении `id`.
+     * @internal
+     */
+    protected _id: string | number;
     readonly runtime: RaphRuntime;
-    private readonly _resources;
-    protected _disposed: boolean;
-    protected _disposing: boolean;
+    /**
+     * Порядковый номер регистрации владельца в его Runtime. Владельцы, пережившие
+     * дерево root, Runtime при собственном освобождении обходит по этому номеру
+     * от нового к старому.
+     * @internal
+     */
+    readonly _order: number;
+    /**
+     * Prototype-бренд для горячих проверок владельца: `true` только у RaphNode.
+     * Значение лежит на prototype и не занимает поле экземпляра.
+     * @internal
+     */
+    readonly _isNode: boolean;
     constructor(id: string, runtime: RaphRuntime);
-    get disposed(): boolean;
-    get active(): boolean;
+    /**
+     * Числовой id зарезервирован за ленивым id по умолчанию у RaphNode.
+     * @internal
+     */
+    constructor(id: string | number, runtime: RaphRuntime);
+    /**
+     * Возвращает id владельца; plain scope всегда хранит явную строку.
+     */
+    get id(): string;
     /** Stable selector for process ordering; plain scopes are not tree nodes. */
     get node(): RaphNode | undefined;
     signal<T>(value: T): Signal<T>;
     computed<T>(getter: () => T): ReadonlySignal<T>;
     computed<T>(options: WritableComputedOptions<T>): Signal<T>;
+    /**
+     * Создаёт selector над записываемым signal: функцию `(key) => boolean`,
+     * которая отвечает, совпадает ли ключ с текущим значением `source`, и
+     * подписывает потребителя только на этот ключ. Запись в `source` будит
+     * потребителей прежнего и нового значения, а не всех читателей.
+     *
+     * Selector принадлежит этому владельцу и живёт до его освобождения; `source`
+     * должен принадлежать самому владельцу, его предку или root scope. Читать
+     * selector вправе те же потребители, что и signal этого владельца.
+     *
+     * @typeParam Key — тип ключа и значения `source`.
+     */
+    selector<Key>(source: Signal<Key>, options?: RaphSelectorOptions<Key>): RaphSelector<Key>;
     effect(phase: string, callback: RaphPhaseEffect, options?: RaphEffectOptions): Disposer;
+    /**
+     * Регистрирует phase effect без task и без disposer. Тело вызывается без
+     * аргументов, а binding живёт до освобождения этого владельца: отдельно его
+     * остановить нельзя. Зависимости, порядок, `initial`, `priority` и cleanup
+     * те же, что у `effect()`.
+     *
+     * Frozen task такого binding создаётся, только если его запросит `process`
+     * своей phase; на регистрацию приходится одна запись binding.
+     * Для тела, которому нужна task или отдельная остановка, остаётся `effect()`.
+     */
+    bindEffect(phase: string, body: RaphPhaseBody, options?: RaphEffectOptions): void;
+    /**
+     * Регистрирует группу из `count` phase effects на одном binding: без task и
+     * без disposer, как `bindEffect()`. `runSlot(run)` — тело каждого slot: оно
+     * получает запуск, где `run[0]` — context группы, а `run[1]` — номер slot.
+     * Чтения внутри вызова отслеживаются отдельно для этого slot, поэтому
+     * изменение зависимости перезапускает только те slots, которые её читали.
+     *
+     * Группа — одна phase task и один ресурс владельца. Регистрация ничего не
+     * исполняет: каждый slot запускает `start(slot, initial?)` возвращённой
+     * группы, и с этого вызова slot ведёт себя как binding, который
+     * `bindEffect()` зарегистрировал бы в этом месте. Доставка исполняет
+     * запущенные slots, чьи зависимости изменились, в порядке их номеров; сбой
+     * одного slot не мешает остальным и сообщается отдельной ошибкой, как сбой
+     * отдельного binding. Причины всех slots складываются в `causes` одной task,
+     * которую custom `process` получает на всю группу. Cleanup, который вернул
+     * slot, выполняется перед его следующим запуском и при освобождении группы.
+     *
+     * Порядок `priority desc → FIFO` действует между tasks: группа занимает в
+     * очереди phase место своего первого изменившегося slot. Внутри task slots
+     * исполняются по номерам, а slot, который изменился, пока его группа
+     * доставляется, исполняется в этой же доставке, если до него ещё не дошла
+     * очередь. Slot, в источник которого записали, пока он ждал запуска в этой
+     * доставке, исполняется в ней один раз и читает новое значение; slot, чьи
+     * зависимости не изменились, тело не исполняет, даже если причина пришла
+     * группе из-за соседнего slot. После доставки, во время которой группе
+     * пришла причина, группа доставляется ещё раз с новыми причинами и
+     * исполняет только slots, изменившиеся после своего запуска; `cancel()`
+     * доставки, во время которой пришла причина, оставляет ждавшие slots
+     * запланированными.
+     *
+     * Группа живёт до освобождения этого владельца: отдельно её остановить
+     * нельзя. Владелец освобождает её после ресурсов, зарегистрированных позже,
+     * в том числе телами её slots; slots освобождаются в порядке, обратном
+     * порядку номеров. Несколько сбоев cleanup при освобождении группы приходят
+     * одним `AggregateError` с сообщением `[Raph] Effect group disposal failed.`
+     * как один сбой ресурса владельца; единственный сбой бросается как есть.
+     *
+     * @typeParam Context — значение, которое получает тело каждого slot.
+     * @param phase Имя объявленной phase.
+     * @param count Число slots: целое от 1 до 4294967293, иначе `RangeError`.
+     * @param runSlot Тело slot: получает запуск с `context` и номером slot.
+     * @param context Значение, которое группа передаёт телу каждого slot.
+     * @param options `priority` task группы, как у `effect()`.
+     */
+    effectGroup<Context>(phase: string, count: number, runSlot: RaphEffectGroupSlot<Context>, context: Context, options?: RaphEffectGroupOptions): RaphEffectGroup;
     watch(source: RaphWatchSource, phase: string, callback: RaphPhaseEffect, options?: RaphWatchOptions): Disposer;
+    /**
+     * Внутренняя регистрация renderer без возвращаемого disposer. Failure
+     * continuation относится только к завершившемуся execution request.
+     * @internal
+     */
+    _registerEffect(phase: string, callback: RaphPhaseEffect, options: RaphEffectOptions, taskless: boolean, onExecutionFailure: (error: unknown) => never, isExecutionCancelled?: () => boolean): void;
+    /** @internal */
+    _registerWatch(source: RaphWatchSource, phase: string, callback: RaphPhaseEffect, options: RaphWatchOptions, onExecutionFailure: (error: unknown) => never, isExecutionCancelled?: () => boolean): void;
+    /**
+     * Выдаёт внутренний typed handle вместо приведения публичного group handle.
+     * Порядок создания и принятия ресурса совпадает с effectGroup().
+     * @internal
+     */
+    _registerEffectGroup<Context>(phase: string, count: number, runSlot: RaphEffectGroupSlot<Context>, context: Context, options?: RaphEffectGroupOptions): ReturnType<RaphRuntime['_effectGroupRegistration']>;
     aggregate(sources: readonly RaphAggregateSource[]): RaphAggregate;
     action<Args extends unknown[], Result>(operation: (...args: Args) => Result): (...args: Args) => Result;
     action<Args extends unknown[], Result>(name: string, operation: (...args: Args) => Result): (...args: Args) => Result;
     own(disposer: Disposer): Disposer;
     dispose(): void;
+    /** Node's super stage keeps the actual public base-method lookup observable. @internal */
+    _disposeScopeForOwner(dispose: Disposer): DisposalFailure | undefined;
+    /** One explicit framework disposal result; public dispose never leaks it. @internal */
+    _disposeWithOutcome(): DisposalFailure | undefined;
+    /** Framework capture registration; ordinary own callback semantics are unchanged. @internal */
+    _ownCompletedCleanup(cleanup: () => DisposalFailure | undefined): Disposer;
     /** @internal */
     _adoptResource(disposer: Disposer): Disposer;
+    /**
+     * Связывает готовую запись ресурса: запись сама становится элементом списка
+     * ресурсов этого владельца, без обёртки и closure, и освобождает себя через
+     * унаследованный _releaseRecord() из собственного dispose().
+     *
+     * @internal
+     */
+    _adoptRecord(entry: OwnedResource): void;
     /** @internal */
     _adoptSource<T>(source: OwnedSource<T>): T;
-    /** @internal */
-    _debugResourceCount(): number;
-    /** @internal */
-    _debugSourceCount(): number;
+    /**
+     * Связывает готовую запись источника: источник сам становится элементом
+     * списка источников этого владельца, без обёртки и closure, и освобождает
+     * себя через собственный _finalizeSource().
+     *
+     * @internal
+     */
+    _adoptSourceEntry(entry: OwnedSourceEntry): void;
     /** @internal */
     _assertAlive(): void;
 }