@design.estate/dees-catalog 3.94.0 → 3.95.0

package/dist_ts_web/elements/00group-layout/dees-mosaic/interaction.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Drag-and-dock gesture for dees-mosaic tilebars: pointer capture with a
+ * movement threshold, a fixed ghost chip, edge-quadrant drop targets with a
+ * live preview, and Escape/blur cancel. The commit path goes through the
+ * pure tree helpers; the component only re-renders from the host's next
+ * layout.
+ */
+import type { DeesMosaic } from './dees-mosaic.js';
+import type { TMosaicDropEdge } from './types.js';
+export interface IMosaicDropTarget {
+    leafId: string;
+    edge: TMosaicDropEdge;
+    previewRect: DOMRect;
+}
+export declare class MosaicDragController {
+    private host;
+    constructor(host: DeesMosaic);
+    private ghost;
+    private shield;
+    private keydownListener;
+    private blurListener;
+    private detachGesture;
+    private activeLeafId;
+    /**
+     * Cancels a gesture that is in flight, e.g. when the host element is
+     * disconnected mid-drag — the pointer will never deliver its up/lost
+     * events to a removed tilebar, so the window listeners must be detached
+     * deterministically here.
+     */
+    cancelActiveGesture(): void;
+    handleTilebarPointerDown(event: PointerEvent, leafId: string, title: string): void;
+    private startDrag;
+    private updateDrag;
+    private resolveDropTarget;
+    private halfRect;
+    private finishDrag;
+}

package/dist_ts_web/elements/00group-layout/dees-mosaic/interaction.js

@@ -0,0 +1,174 @@
+import { mosaicMove } from './tree.js';
+const dragThresholdPx = 4;
+export class MosaicDragController {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    ghost = null;
+    shield = null;
+    keydownListener = null;
+    blurListener = null;
+    detachGesture = null;
+    activeLeafId = null;
+    /**
+     * Cancels a gesture that is in flight, e.g. when the host element is
+     * disconnected mid-drag — the pointer will never deliver its up/lost
+     * events to a removed tilebar, so the window listeners must be detached
+     * deterministically here.
+     */
+    cancelActiveGesture() {
+        this.detachGesture?.();
+        if (this.ghost && this.activeLeafId !== null) {
+            this.finishDrag(this.activeLeafId, false);
+        }
+        this.activeLeafId = null;
+    }
+    handleTilebarPointerDown(event, leafId, title) {
+        if (!this.host.dragEnabled || event.button !== 0)
+            return;
+        if (this.detachGesture)
+            return; // one gesture at a time (multi-touch guard)
+        const tilebar = event.currentTarget;
+        const pointerId = event.pointerId;
+        const startX = event.clientX;
+        const startY = event.clientY;
+        let started = false;
+        const onMove = (moveEvent) => {
+            if (!started) {
+                if (Math.hypot(moveEvent.clientX - startX, moveEvent.clientY - startY) < dragThresholdPx)
+                    return;
+                started = true;
+                this.startDrag(tilebar, leafId, title);
+            }
+            this.updateDrag(moveEvent, leafId);
+        };
+        const cleanup = () => {
+            this.detachGesture = null;
+            tilebar.removeEventListener('pointermove', onMove);
+            tilebar.removeEventListener('pointerup', onUp);
+            tilebar.removeEventListener('lostpointercapture', onLost);
+            try {
+                tilebar.releasePointerCapture(pointerId);
+            }
+            catch {
+                // not captured (synthetic pointer or already released)
+            }
+        };
+        const onUp = () => {
+            cleanup();
+            if (started)
+                this.finishDrag(leafId, true);
+        };
+        const onLost = () => {
+            cleanup();
+            if (started)
+                this.finishDrag(leafId, false);
+        };
+        try {
+            tilebar.setPointerCapture(pointerId);
+        }
+        catch {
+            // synthetic pointers (tests) cannot be captured; listeners work anyway
+        }
+        this.detachGesture = cleanup;
+        this.activeLeafId = leafId;
+        tilebar.addEventListener('pointermove', onMove);
+        tilebar.addEventListener('pointerup', onUp);
+        tilebar.addEventListener('lostpointercapture', onLost);
+    }
+    startDrag(tilebar, leafId, title) {
+        tilebar.classList.add('dragging');
+        const root = this.host.shadowRoot.querySelector('.rootBox');
+        this.shield = document.createElement('div');
+        this.shield.className = 'dragShield';
+        root.appendChild(this.shield);
+        this.ghost = document.createElement('div');
+        this.ghost.className = 'dragGhost';
+        this.ghost.textContent = title;
+        root.appendChild(this.ghost);
+        this.keydownListener = (event) => {
+            if (event.key === 'Escape') {
+                event.preventDefault();
+                this.finishDrag(leafId, false);
+            }
+        };
+        this.blurListener = () => this.finishDrag(leafId, false);
+        window.addEventListener('keydown', this.keydownListener, true);
+        window.addEventListener('blur', this.blurListener);
+        this.host.dispatchEvent(new CustomEvent('mosaic-drag-state', {
+            detail: { dragging: true, leafId },
+            bubbles: true,
+            composed: true,
+        }));
+    }
+    updateDrag(event, draggedLeafId) {
+        if (this.ghost) {
+            this.ghost.style.left = `${event.clientX}px`;
+            this.ghost.style.top = `${event.clientY}px`;
+        }
+        this.host.dropTarget = this.resolveDropTarget(event.clientX, event.clientY, draggedLeafId);
+    }
+    resolveDropTarget(x, y, draggedLeafId) {
+        const rects = this.host.getLeafRects();
+        for (const [leafId, rect] of Object.entries(rects)) {
+            if (leafId === draggedLeafId)
+                continue;
+            if (x < rect.left || x > rect.right || y < rect.top || y > rect.bottom)
+                continue;
+            const distances = [
+                ['left', x - rect.left],
+                ['right', rect.right - x],
+                ['top', y - rect.top],
+                ['bottom', rect.bottom - y],
+            ];
+            distances.sort((a, b) => a[1] - b[1]);
+            const edge = distances[0][0];
+            const previewRect = this.halfRect(rect, edge);
+            return { leafId, edge, previewRect };
+        }
+        return null;
+    }
+    halfRect(rect, edge) {
+        if (edge === 'left')
+            return new DOMRect(rect.left, rect.top, rect.width / 2, rect.height);
+        if (edge === 'right')
+            return new DOMRect(rect.left + rect.width / 2, rect.top, rect.width / 2, rect.height);
+        if (edge === 'top')
+            return new DOMRect(rect.left, rect.top, rect.width, rect.height / 2);
+        return new DOMRect(rect.left, rect.top + rect.height / 2, rect.width, rect.height / 2);
+    }
+    finishDrag(leafId, commit) {
+        // cancel paths (Escape/blur) arrive outside the pointer handlers: detach
+        // the gesture listeners so a held pointer can no longer revive or commit
+        // the cancelled drag on a later move/release
+        this.detachGesture?.();
+        this.activeLeafId = null;
+        const target = this.host.dropTarget;
+        this.host.dropTarget = null;
+        for (const tilebar of this.host.shadowRoot?.querySelectorAll('.tilebar.dragging') ?? []) {
+            tilebar.classList.remove('dragging');
+        }
+        this.ghost?.remove();
+        this.ghost = null;
+        this.shield?.remove();
+        this.shield = null;
+        if (this.keydownListener) {
+            window.removeEventListener('keydown', this.keydownListener, true);
+            this.keydownListener = null;
+        }
+        if (this.blurListener) {
+            window.removeEventListener('blur', this.blurListener);
+            this.blurListener = null;
+        }
+        this.host.dispatchEvent(new CustomEvent('mosaic-drag-state', {
+            detail: { dragging: false, leafId },
+            bubbles: true,
+            composed: true,
+        }));
+        if (commit && target) {
+            this.host.commitLayout(mosaicMove(this.host.layout, leafId, target.leafId, target.edge), 'drop');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interaction.js","sourceRoot":"","sources":["../../../../ts_web/elements/00group-layout/dees-mosaic/interaction.ts"],"names":[],"mappings":"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"}

package/dist_ts_web/elements/00group-layout/dees-mosaic/tree.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Pure tree algebra for dees-mosaic layouts. No DOM access; unit-testable in
+ * node. Every mutation helper returns a NEW normalized layout; inputs are
+ * never mutated.
+ *
+ * Normalization invariants:
+ * - a split with a single child collapses to that child
+ * - nested splits with the same orientation merge into the parent
+ * - ratios.length === children.length, summing to 1, each held at or near
+ *   the minimum share (single-pass redistribution may undershoot slightly)
+ * - an empty tree is { root: null }
+ */
+import type { IMosaicLayout, IMosaicLeafNode, TMosaicDropEdge } from './types.js';
+export declare const createMosaicId: (prefix: string) => string;
+export declare const createMosaicLeaf: (surface: string, id?: string) => IMosaicLeafNode;
+export declare const mosaicNormalize: (layout: IMosaicLayout) => IMosaicLayout;
+export declare const mosaicLeaves: (layout: IMosaicLayout) => IMosaicLeafNode[];
+export declare const mosaicFindLeafBySurface: (layout: IMosaicLayout, surface: string) => IMosaicLeafNode | undefined;
+export declare const mosaicFindLeaf: (layout: IMosaicLayout, leafId: string) => IMosaicLeafNode | undefined;
+/** Removes a leaf; collapsing/merging is handled by normalization. */
+export declare const mosaicRemove: (layout: IMosaicLayout, leafId: string) => IMosaicLayout;
+/**
+ * Inserts a leaf next to targetLeafId on the given edge (splitting the target
+ * 50/50 along the edge's axis). targetLeafId null docks against the whole
+ * layout (or becomes the root of an empty one).
+ */
+export declare const mosaicInsert: (layout: IMosaicLayout, targetLeafId: string | null, edge: TMosaicDropEdge, leaf: IMosaicLeafNode) => IMosaicLayout;
+/** Transfers ratio between two adjacent siblings of a split. */
+export declare const mosaicResize: (layout: IMosaicLayout, splitId: string, dividerIndex: number, ratioDelta: number) => IMosaicLayout;
+/** Equalizes the ratios of one split (or every split when splitId omitted). */
+export declare const mosaicEqualize: (layout: IMosaicLayout, splitId?: string) => IMosaicLayout;
+/** Moves an existing leaf next to another leaf (drag-and-dock commit). */
+export declare const mosaicMove: (layout: IMosaicLayout, leafId: string, targetLeafId: string, edge: TMosaicDropEdge) => IMosaicLayout;

package/dist_ts_web/elements/00group-layout/dees-mosaic/tree.js

@@ -0,0 +1,199 @@
+const minRatio = 0.05;
+let idCounter = 0;
+export const createMosaicId = (prefix) => {
+    idCounter += 1;
+    return `${prefix}-${Date.now().toString(36)}-${idCounter.toString(36)}`;
+};
+export const createMosaicLeaf = (surface, id) => ({
+    type: 'leaf',
+    id: id ?? createMosaicId('leaf'),
+    surface,
+});
+const cloneNode = (node) => {
+    if (node.type === 'leaf')
+        return { ...node };
+    return {
+        ...node,
+        children: node.children.map(cloneNode),
+        ratios: [...node.ratios],
+    };
+};
+const normalizeRatios = (ratios, count) => {
+    let next = ratios.slice(0, count);
+    while (next.length < count)
+        next.push(1 / count);
+    next = next.map((ratio) => (Number.isFinite(ratio) && ratio > 0 ? ratio : 1 / count));
+    const sum = next.reduce((total, ratio) => total + ratio, 0);
+    next = next.map((ratio) => ratio / sum);
+    // clamp to the minimum share, re-distributing the deficit proportionally
+    const deficitIndices = next.map((ratio, index) => (ratio < minRatio ? index : -1)).filter((index) => index >= 0);
+    if (deficitIndices.length && deficitIndices.length < count) {
+        const deficit = deficitIndices.reduce((total, index) => total + (minRatio - next[index]), 0);
+        const donorSum = next.reduce((total, ratio, index) => (deficitIndices.includes(index) ? total : total + ratio), 0);
+        next = next.map((ratio, index) => {
+            if (deficitIndices.includes(index))
+                return minRatio;
+            return ratio - (deficit * ratio) / donorSum;
+        });
+    }
+    return next;
+};
+const normalizeNode = (node) => {
+    if (node.type === 'leaf')
+        return { ...node };
+    const flattenedChildren = [];
+    const flattenedRatios = [];
+    node.children.forEach((child, index) => {
+        const normalizedChild = normalizeNode(child);
+        if (!normalizedChild)
+            return;
+        const ratio = node.ratios[index] ?? 1 / node.children.length;
+        if (normalizedChild.type === 'split' && normalizedChild.orientation === node.orientation) {
+            // merge same-orientation splits: children inherit a share of the slot
+            normalizedChild.children.forEach((grandChild, grandIndex) => {
+                flattenedChildren.push(grandChild);
+                flattenedRatios.push(ratio * normalizedChild.ratios[grandIndex]);
+            });
+            return;
+        }
+        flattenedChildren.push(normalizedChild);
+        flattenedRatios.push(ratio);
+    });
+    if (!flattenedChildren.length)
+        return null;
+    if (flattenedChildren.length === 1)
+        return flattenedChildren[0];
+    return {
+        type: 'split',
+        id: node.id,
+        orientation: node.orientation,
+        children: flattenedChildren,
+        ratios: normalizeRatios(flattenedRatios, flattenedChildren.length),
+    };
+};
+export const mosaicNormalize = (layout) => {
+    if (!layout.root)
+        return { root: null };
+    return { root: normalizeNode(cloneNode(layout.root)) };
+};
+export const mosaicLeaves = (layout) => {
+    const leaves = [];
+    const walk = (node) => {
+        if (!node)
+            return;
+        if (node.type === 'leaf') {
+            leaves.push(node);
+            return;
+        }
+        node.children.forEach(walk);
+    };
+    walk(layout.root);
+    return leaves;
+};
+export const mosaicFindLeafBySurface = (layout, surface) => mosaicLeaves(layout).find((leaf) => leaf.surface === surface);
+export const mosaicFindLeaf = (layout, leafId) => mosaicLeaves(layout).find((leaf) => leaf.id === leafId);
+/** Removes a leaf; collapsing/merging is handled by normalization. */
+export const mosaicRemove = (layout, leafId) => {
+    const removeFrom = (node) => {
+        if (node.type === 'leaf')
+            return node.id === leafId ? null : node;
+        const children = [];
+        const ratios = [];
+        node.children.forEach((child, index) => {
+            const kept = removeFrom(child);
+            if (!kept)
+                return;
+            children.push(kept);
+            ratios.push(node.ratios[index]);
+        });
+        if (!children.length)
+            return null;
+        return { ...node, children, ratios };
+    };
+    if (!layout.root)
+        return { root: null };
+    const root = removeFrom(cloneNode(layout.root));
+    return mosaicNormalize({ root });
+};
+const edgeOrientation = (edge) => edge === 'left' || edge === 'right' ? 'row' : 'column';
+const edgeBefore = (edge) => edge === 'left' || edge === 'top';
+/**
+ * Inserts a leaf next to targetLeafId on the given edge (splitting the target
+ * 50/50 along the edge's axis). targetLeafId null docks against the whole
+ * layout (or becomes the root of an empty one).
+ */
+export const mosaicInsert = (layout, targetLeafId, edge, leaf) => {
+    if (!layout.root)
+        return { root: { ...leaf } };
+    const orientation = edgeOrientation(edge);
+    const before = edgeBefore(edge);
+    const wrap = (node) => ({
+        type: 'split',
+        id: createMosaicId('split'),
+        orientation,
+        children: before ? [{ ...leaf }, node] : [node, { ...leaf }],
+        ratios: [0.5, 0.5],
+    });
+    if (targetLeafId === null) {
+        return mosaicNormalize({ root: wrap(cloneNode(layout.root)) });
+    }
+    const insertInto = (node) => {
+        if (node.type === 'leaf') {
+            return node.id === targetLeafId ? wrap(node) : node;
+        }
+        return { ...node, children: node.children.map(insertInto) };
+    };
+    return mosaicNormalize({ root: insertInto(cloneNode(layout.root)) });
+};
+/** Transfers ratio between two adjacent siblings of a split. */
+export const mosaicResize = (layout, splitId, dividerIndex, ratioDelta) => {
+    const apply = (node) => {
+        if (node.type === 'leaf')
+            return node;
+        if (node.id !== splitId) {
+            return { ...node, children: node.children.map(apply) };
+        }
+        const ratios = [...node.ratios];
+        const leftIndex = dividerIndex;
+        const rightIndex = dividerIndex + 1;
+        if (leftIndex < 0 || rightIndex >= ratios.length)
+            return node;
+        const pair = ratios[leftIndex] + ratios[rightIndex];
+        const nextLeft = Math.min(Math.max(ratios[leftIndex] + ratioDelta, minRatio), pair - minRatio);
+        ratios[leftIndex] = nextLeft;
+        ratios[rightIndex] = pair - nextLeft;
+        return { ...node, ratios };
+    };
+    if (!layout.root)
+        return { root: null };
+    return { root: apply(cloneNode(layout.root)) };
+};
+/** Equalizes the ratios of one split (or every split when splitId omitted). */
+export const mosaicEqualize = (layout, splitId) => {
+    const apply = (node) => {
+        if (node.type === 'leaf')
+            return node;
+        const children = node.children.map(apply);
+        if (!splitId || node.id === splitId) {
+            return { ...node, children, ratios: children.map(() => 1 / children.length) };
+        }
+        return { ...node, children };
+    };
+    if (!layout.root)
+        return { root: null };
+    return { root: apply(cloneNode(layout.root)) };
+};
+/** Moves an existing leaf next to another leaf (drag-and-dock commit). */
+export const mosaicMove = (layout, leafId, targetLeafId, edge) => {
+    if (leafId === targetLeafId)
+        return mosaicNormalize(layout);
+    const leaf = mosaicFindLeaf(layout, leafId);
+    if (!leaf)
+        return mosaicNormalize(layout);
+    const without = mosaicRemove(layout, leafId);
+    // the target may have been the leaf's only sibling — it still exists
+    if (!mosaicFindLeaf(without, targetLeafId))
+        return mosaicNormalize(layout);
+    return mosaicInsert(without, targetLeafId, edge, { ...leaf });
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.js","sourceRoot":"","sources":["../../../../ts_web/elements/00group-layout/dees-mosaic/tree.ts"],"names":[],"mappings":"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"}

package/dist_ts_web/elements/00group-layout/dees-mosaic/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * dees-mosaic — sway-like tiling layout model. A layout is a tree of split
+ * containers whose leaves reference host-defined surfaces. The component is
+ * controlled: hosts own the layout object and receive complete next layouts
+ * through events; the tree helpers in tree.ts are pure and DOM-free.
+ */
+export type TMosaicOrientation = 'row' | 'column';
+export interface IMosaicLeafNode {
+    type: 'leaf';
+    /** stable node id — the slot contract is slot="tile-<id>" */
+    id: string;
+    /** host-defined surface key, e.g. 'chat' | 'theia' | 'browser' */
+    surface: string;
+    /** optional per-leaf override of the surface meta title */
+    title?: string;
+}
+export interface IMosaicSplitNode {
+    type: 'split';
+    id: string;
+    orientation: TMosaicOrientation;
+    /** length >= 2 after normalization */
+    children: TMosaicNode[];
+    /** same length as children; each >= minimum share; sums to 1 */
+    ratios: number[];
+}
+export type TMosaicNode = IMosaicLeafNode | IMosaicSplitNode;
+export interface IMosaicLayout {
+    /** null = empty workspace (the `empty` slot renders) */
+    root: TMosaicNode | null;
+}
+export interface IMosaicSurfaceMeta {
+    title: string;
+    /** dees-icon name, e.g. 'lucide:Globe' */
+    icon?: string;
+    /** default true */
+    closeable?: boolean;
+}
+export type TMosaicDropEdge = 'left' | 'right' | 'top' | 'bottom';
+export type TMosaicLayoutChangeReason = 'resize' | 'drop' | 'close' | 'equalize';
+export interface IMosaicLayoutChangeDetail {
+    /** the complete next layout — the host applies and persists it */
+    layout: IMosaicLayout;
+    reason: TMosaicLayoutChangeReason;
+}
+export interface IMosaicTileEventDetail {
+    leafId: string;
+    surface: string;
+}
+export interface IMosaicDragStateDetail {
+    dragging: boolean;
+    leafId?: string;
+}

package/dist_ts_web/elements/00group-layout/dees-mosaic/types.js

@@ -0,0 +1,8 @@
+/**
+ * dees-mosaic — sway-like tiling layout model. A layout is a tree of split
+ * containers whose leaves reference host-defined surfaces. The component is
+ * controlled: hosts own the layout object and receive complete next layouts
+ * through events; the tree helpers in tree.ts are pure and DOM-free.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90c193ZWIvZWxlbWVudHMvMDBncm91cC1sYXlvdXQvZGVlcy1tb3NhaWMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O0dBS0cifQ==

package/dist_ts_web/elements/00group-layout/index.d.ts

@@ -3,6 +3,7 @@ export * from './dees-dashboardgrid/index.js';
 export * from './dees-heading/index.js';
 export * from './dees-label/index.js';
 export * from './dees-pagination/index.js';
+export * from './dees-mosaic/index.js';
 export * from './dees-panel/index.js';
 export * from './dees-settings/index.js';
 export * from './dees-sparklebox/index.js';

package/dist_ts_web/elements/00group-layout/index.js

@@ -4,9 +4,10 @@ export * from './dees-dashboardgrid/index.js';
 export * from './dees-heading/index.js';
 export * from './dees-label/index.js';
 export * from './dees-pagination/index.js';
+export * from './dees-mosaic/index.js';
 export * from './dees-panel/index.js';
 export * from './dees-settings/index.js';
 export * from './dees-sparklebox/index.js';
 export * from './dees-stepper/index.js';
 export * from './dees-tile/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90c193ZWIvZWxlbWVudHMvMDBncm91cC1sYXlvdXQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsc0JBQXNCLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90c193ZWIvZWxlbWVudHMvMDBncm91cC1sYXlvdXQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxzQkFBc0IsQ0FBQyJ9