@voithos-labs/aragonite 0.10.1

package/dist/components/image/image-edit-commit.js

@@ -0,0 +1,159 @@
+import { resolvedInlineContent } from '../../core/inline/inline-cache';
+import { flattenInlineWidgets } from '../../core/inline/inline-widgets';
+import { createInlineRangeCommit } from '../../editor-actions/inline-range-commit';
+import { FALLBACK_CONTENT_WIDTH } from '../../cursor/typography-estimates';
+import { blockNodeAt } from '../../tree-operations/node-ops';
+import { buildImageEditBytes } from './image-source-bytes';
+export function createImageEditCommitter(deps) {
+    const { getDoc, getEditorEl, widgetSelection, controller, events } = deps;
+    const inlineRange = createInlineRangeCommit({ getDoc, controller, grammar: deps.grammar });
+    function findImageInParagraph(para, sourceStart) {
+        // Resolver-aware so a reference-style image resolves as the render path saw it,
+        // and flattened so an image nested in a link (`[![alt][ref]][repo]`) is found.
+        const inlines = resolvedInlineContent(para, deps.linkRef);
+        for (const widget of flattenInlineWidgets(inlines, para.raw)) {
+            if (widget.kind === 'image' && widget.start === sourceStart)
+                return widget;
+        }
+        return null;
+    }
+    function queryWidgetEl(paragraphPath, sourceStart) {
+        const root = getEditorEl();
+        if (!root)
+            return null;
+        // Locate by the live block-host path, never a baked attribute on the widget —
+        // see widget-dom.ts's click handler.
+        const host = root.querySelector(`[data-block-path='${JSON.stringify(paragraphPath)}']`);
+        if (!host)
+            return null;
+        return host.querySelector(`[data-image-widget][data-source-start="${sourceStart}"]`);
+    }
+    function getSelectedImageFields() {
+        const sel = widgetSelection.getSelected();
+        if (!sel)
+            return null;
+        const paragraph = blockNodeAt(getDoc(), sel.paragraphPath);
+        if (!paragraph)
+            return null;
+        const image = findImageInParagraph(paragraph, sel.sourceStart);
+        if (!image)
+            return null;
+        return { image, widgetEl: queryWidgetEl(sel.paragraphPath, sel.sourceStart) };
+    }
+    function resolveEdit(target, newFields) {
+        const paragraph = blockNodeAt(getDoc(), target.paragraphPath);
+        if (!paragraph)
+            return null;
+        const image = findImageInParagraph(paragraph, target.sourceStart);
+        if (!image)
+            return null;
+        // Preserve the reference form when url/title are untouched: inlining the
+        // resolved url would orphan the LRD. Changing either is the user opting in.
+        const fields = image.label !== undefined && newFields.url === image.url && newFields.title === image.title
+            ? { ...newFields, label: image.label }
+            : newFields;
+        const bytes = buildImageEditBytes(image, paragraph.raw, fields);
+        return bytes === null ? null : { image, bytes };
+    }
+    function buildEditBytes(target, newFields) {
+        return resolveEdit(target, newFields)?.bytes ?? null;
+    }
+    function commitImageEdit(target, newFields) {
+        const edit = resolveEdit(target, newFields);
+        if (!edit)
+            return;
+        void inlineRange.commitInlineRange(target.paragraphPath, edit.image.start, edit.image.end, edit.bytes, 0);
+    }
+    function commitImageResize(newWidth, newHeight) {
+        const sel = widgetSelection.getSelected();
+        if (!sel)
+            return;
+        const ctx = getSelectedImageFields();
+        if (!ctx)
+            return;
+        const newFields = {
+            alt: ctx.image.alt ?? '',
+            url: ctx.image.url ?? '',
+            ...(ctx.image.title !== undefined ? { title: ctx.image.title } : {}),
+            width: newWidth,
+            ...(newHeight !== undefined ? { height: newHeight } : {})
+        };
+        commitImageEdit(sel, newFields);
+    }
+    function dismissImagePopover() {
+        widgetSelection.clear();
+    }
+    function getEditorContentWidth() {
+        return getEditorEl()?.clientWidth ?? FALLBACK_CONTENT_WIDTH;
+    }
+    function attachWidgetSelectListener() {
+        const root = getEditorEl();
+        if (!root)
+            return () => { };
+        const handler = (e) => widgetSelection.select(e.detail);
+        root.addEventListener('image-widget-select', handler);
+        return () => root.removeEventListener('image-widget-select', handler);
+    }
+    function syncOverlayToWidget(getOverlay) {
+        const noop = () => { };
+        const overlayEl = getOverlay();
+        const editorEl = getEditorEl();
+        if (!overlayEl || !editorEl)
+            return noop;
+        // Each commit rebuilds the inline DOM, so a captured widget ref would observe a
+        // detached node forever: re-resolve on every update and re-attach the observer
+        // when widget identity changes.
+        let observer = null;
+        let observed = null;
+        const update = () => {
+            const widgetEl = getSelectedImageFields()?.widgetEl;
+            if (!widgetEl)
+                return;
+            if (widgetEl !== observed) {
+                observer?.disconnect();
+                observer = new ResizeObserver(update);
+                observer.observe(widgetEl);
+                observed = widgetEl;
+            }
+            const wRect = widgetEl.getBoundingClientRect();
+            const eRect = editorEl.getBoundingClientRect();
+            const cs = getComputedStyle(editorEl);
+            const borderTop = parseFloat(cs.borderTopWidth) || 0;
+            const borderLeft = parseFloat(cs.borderLeftWidth) || 0;
+            overlayEl.style.top = `${wRect.top - eRect.top - borderTop + editorEl.scrollTop}px`;
+            overlayEl.style.left = `${wRect.left - eRect.left - borderLeft + editorEl.scrollLeft}px`;
+            overlayEl.style.width = `${wRect.width}px`;
+            overlayEl.style.height = `${wRect.height}px`;
+        };
+        update();
+        // Edits above the widget shift its y without resizing it.
+        const unsubscribeEdit = events.on('edit', update);
+        window.addEventListener('resize', update);
+        // Sibling images settling their dimensions shift the selected widget's y without
+        // resizing it, which the ResizeObserver never sees. Capture phase: neither
+        // event bubbles.
+        const onImgSettle = (e) => {
+            if (e.target instanceof HTMLImageElement)
+                update();
+        };
+        editorEl.addEventListener('load', onImgSettle, true);
+        editorEl.addEventListener('error', onImgSettle, true);
+        return () => {
+            observer?.disconnect();
+            unsubscribeEdit();
+            window.removeEventListener('resize', update);
+            editorEl.removeEventListener('load', onImgSettle, true);
+            editorEl.removeEventListener('error', onImgSettle, true);
+        };
+    }
+    return {
+        getSelectedImageFields,
+        commitImageEdit,
+        buildEditBytes,
+        commitImageResize,
+        dismissImagePopover,
+        getEditorContentWidth,
+        attachWidgetSelectListener,
+        syncOverlayToWidget
+    };
+}

package/dist/components/image/image-resize.d.ts

@@ -0,0 +1,11 @@
+export declare const MIN_WIDTH = 16;
+export declare function clampWidth(width: number, maxWidth: number): number;
+export declare const KEYBOARD_MIN_WIDTH = 32;
+export declare function keyboardResizeWidth(currentWidth: number, delta: number, maxWidth: number): number;
+export declare function snapWidth(width: number, maxWidth: number, snapThresholdPx: number): number;
+/**
+ * The height a release persists — the one the drag showed. An aspect-locked drag lets the height
+ * follow the width, so it persists `|N` and leaves the derivation to the renderer; an unlocked
+ * drag holds the height the image already had, which only the explicit `|NxM` form can carry.
+ */
+export declare function resolveDraggedHeight(aspectLocked: boolean, previewHeight: number): number | undefined;

package/dist/components/image/image-resize.js

@@ -0,0 +1,38 @@
+// Pure math for image drag-to-resize: clamp, snap-to-percentage, aspect lock.
+// No DOM — the handles component owns pointer events and calls these.
+export const MIN_WIDTH = 16;
+const SNAP_PERCENTAGES = [25, 50, 75, 100];
+export function clampWidth(width, maxWidth) {
+    const rounded = Math.round(width);
+    if (rounded < MIN_WIDTH)
+        return MIN_WIDTH;
+    if (rounded > maxWidth)
+        return maxWidth;
+    return rounded;
+}
+// Above MIN_WIDTH so a held Shift+Arrow can't shrink an image to a sub-clickable
+// sliver; the ceiling matches the drag path.
+export const KEYBOARD_MIN_WIDTH = 32;
+export function keyboardResizeWidth(currentWidth, delta, maxWidth) {
+    return clampWidth(Math.max(KEYBOARD_MIN_WIDTH, currentWidth + delta), maxWidth);
+}
+export function snapWidth(width, maxWidth, snapThresholdPx) {
+    const rounded = Math.round(width);
+    for (const pct of SNAP_PERCENTAGES) {
+        const target = Math.round((maxWidth * pct) / 100);
+        if (Math.abs(rounded - target) <= snapThresholdPx)
+            return target;
+    }
+    return rounded;
+}
+/**
+ * The height a release persists — the one the drag showed. An aspect-locked drag lets the height
+ * follow the width, so it persists `|N` and leaves the derivation to the renderer; an unlocked
+ * drag holds the height the image already had, which only the explicit `|NxM` form can carry.
+ */
+export function resolveDraggedHeight(aspectLocked, previewHeight) {
+    // A widget that never laid out reports 0; `|Nx0` is worse than no hint at all.
+    if (aspectLocked || previewHeight < 1)
+        return undefined;
+    return Math.round(previewHeight);
+}

package/dist/components/image/image-source-bytes.d.ts

@@ -0,0 +1,15 @@
+import type { ImageFields, InlineNode } from '../../core/nodes';
+/**
+ * Bytes to splice over `image`'s range, or `null` when the edit must be declined. **Every image
+ * write path goes through here** (G4.21): a node an inline rung claimed re-serializes through that
+ * rung's `rewriteImage` hook, since built-in grammar over another syntax's bytes destroys them.
+ * Plugin-side contract: docs/design/plugin-contract.md § Inline authoring.
+ */
+export declare function buildImageEditBytes(image: InlineNode, blockRaw: string, fields: ImageFields): string | null;
+/** Omits optional keys the node doesn't carry, so a rebuild writes back only what the
+ *  source held. Byte-exactness is not the claim (the GFM serializer canonicalizes);
+ *  idempotence on the alt is, so repeated resizes never grow the escapes. */
+export declare function imageFieldsFromInline(image: InlineNode): ImageFields;
+/** The built-in grammar's inverse. Reach it through `buildImageEditBytes`, the only
+ *  caller entitled to decide these bytes are GFM's to write. */
+export declare function buildImageSourceBytes(fields: ImageFields): string;

package/dist/components/image/image-source-bytes.js

@@ -0,0 +1,73 @@
+// Where an image edit becomes bytes: the claim dispatcher every write path calls, and
+// under it the GFM branch. The two live together because G4.21 requires the image
+// serializer to be named in exactly one module.
+import { encodeDestination, escapeTitle } from '../../core/inline/destination-bytes';
+import { devWarn } from '../../dev-warn';
+// ── The write seam ──────────────────────────────────────────────────────────
+/**
+ * Bytes to splice over `image`'s range, or `null` when the edit must be declined. **Every image
+ * write path goes through here** (G4.21): a node an inline rung claimed re-serializes through that
+ * rung's `rewriteImage` hook, since built-in grammar over another syntax's bytes destroys them.
+ * Plugin-side contract: docs/design/plugin-contract.md § Inline authoring.
+ */
+export function buildImageEditBytes(image, blockRaw, fields) {
+    const claim = image.syntaxClaim;
+    if (!claim)
+        return buildImageSourceBytes(fields);
+    const bytes = claim.rewriteImage?.(blockRaw.slice(image.start, image.end), fields) ?? null;
+    if (bytes === null) {
+        devWarn('image-edit', `declined: the "${claim.prefix}" inline rung owns these bytes and ` +
+            `${claim.rewriteImage ? 'its rewriteImage hook cannot represent this edit' : 'registered no rewriteImage hook'}`, fields);
+    }
+    return bytes;
+}
+/** Omits optional keys the node doesn't carry, so a rebuild writes back only what the
+ *  source held. Byte-exactness is not the claim (the GFM serializer canonicalizes);
+ *  idempotence on the alt is, so repeated resizes never grow the escapes. */
+export function imageFieldsFromInline(image) {
+    return {
+        alt: image.alt ?? '',
+        url: image.url ?? '',
+        ...(image.title !== undefined ? { title: image.title } : {}),
+        ...(image.width !== undefined ? { width: image.width } : {}),
+        ...(image.height !== undefined ? { height: image.height } : {}),
+        ...(image.label !== undefined ? { label: image.label } : {})
+    };
+}
+// ── The GFM serializer ──────────────────────────────────────────────────────
+/** The built-in grammar's inverse. Reach it through `buildImageEditBytes`, the only
+ *  caller entitled to decide these bytes are GFM's to write. */
+export function buildImageSourceBytes(fields) {
+    const dimSuffix = buildDimSuffix(fields.width, fields.height);
+    const altSegment = escapeAlt(fields.alt) + dimSuffix;
+    // Reference form: the dimension hint rides in the alt, and url/title are not
+    // written — they belong to the LRD.
+    if (fields.label !== undefined) {
+        return `![${altSegment}][${fields.label}]`;
+    }
+    const titleSegment = fields.title !== undefined ? ` "${escapeTitle(fields.title)}"` : '';
+    return `![${altSegment}](${encodeDestination(fields.url)}${titleSegment})`;
+}
+function buildDimSuffix(width, height) {
+    if (width === undefined)
+        return '';
+    if (height === undefined)
+        return `|${width}`;
+    return `|${width}x${height}`;
+}
+// Alt sits inside `[...]`, where an unescaped bracket closes the scan early. Unlike
+// `title` and `url` it carries RAW label bytes, so a blanket escape doubles every
+// backslash per commit; passing any backslash PAIR through untouched keeps it idempotent.
+function escapeAlt(alt) {
+    let out = '';
+    for (let i = 0; i < alt.length; i++) {
+        const ch = alt[i];
+        if (ch === '\\' && i + 1 < alt.length) {
+            out += ch + alt[i + 1];
+            i++;
+            continue;
+        }
+        out += ch === '[' || ch === ']' || ch === '\\' ? '\\' + ch : ch;
+    }
+    return out;
+}

package/dist/components/image/image-widget-editing.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The image widget's selected-key behavior: Shift+Arrow keyboard resize. Attached as
+ * the image kind's `onSelectedKey` at mount (built-in-blocks.ts), so the generic
+ * selected-widget keydown path stays kind-agnostic.
+ */
+import type { InlineWidgetEditingContext } from '../../core/inline/inline-widgets';
+export declare function imageWidgetOnSelectedKey(e: KeyboardEvent, ctx: InlineWidgetEditingContext): boolean;

package/dist/components/image/image-widget-editing.js

@@ -0,0 +1,41 @@
+/**
+ * The image widget's selected-key behavior: Shift+Arrow keyboard resize. Attached as
+ * the image kind's `onSelectedKey` at mount (built-in-blocks.ts), so the generic
+ * selected-widget keydown path stays kind-agnostic.
+ */
+import { buildImageEditBytes } from './image-source-bytes';
+import { keyboardResizeWidth } from './image-resize';
+const KEYBOARD_STEP = 20;
+const FALLBACK_DEFAULT_WIDTH = 400;
+export function imageWidgetOnSelectedKey(e, ctx) {
+    // A resize is an edit; declining lets the caller's generic swallow keep the key inert.
+    if (ctx.presentationMode === 'reading')
+        return false;
+    if (!(e.shiftKey && (e.key === 'ArrowLeft' || e.key === 'ArrowRight')))
+        return false;
+    e.preventDefault();
+    const { inline, node } = ctx;
+    const delta = e.key === 'ArrowRight' ? KEYBOARD_STEP : -KEYBOARD_STEP;
+    const currentWidth = inline.width ?? FALLBACK_DEFAULT_WIDTH;
+    const newWidth = keyboardResizeWidth(currentWidth, delta, ctx.editorContentWidth);
+    // url and title are untouched, so carry the label through and preserve the
+    // `![alt][label]` form rather than inlining the LRD-resolved url.
+    const newFields = {
+        alt: inline.alt ?? '',
+        url: inline.url ?? '',
+        ...(inline.title !== undefined ? { title: inline.title } : {}),
+        width: newWidth,
+        ...(inline.height !== undefined
+            ? { height: Math.round((newWidth / currentWidth) * inline.height) }
+            : {}),
+        ...(inline.label !== undefined ? { label: inline.label } : {})
+    };
+    const newBytes = buildImageEditBytes(inline, node.raw, newFields);
+    // The rung owning these bytes cannot express the resize, but consume the key
+    // anyway: handing a Shift+Arrow on would extend the selection out of the image.
+    if (newBytes === null)
+        return true;
+    const newRaw = node.raw.slice(0, ctx.widgetStart) + newBytes + node.raw.slice(ctx.widgetEnd);
+    ctx.updateContent(newRaw, ctx.preSelectOffset, ctx.widgetStart + newBytes.length);
+    return true;
+}

package/dist/components/image/widget-dom.d.ts

@@ -0,0 +1,11 @@
+import type { InlineNode } from '../../core/nodes';
+import type { ImageLoadPolicy } from '../../core/inline-render';
+export interface BuildImageWidgetOpts {
+    resolveImageUrl: (rawUrl: string) => string;
+    imageLoadPolicy?: ImageLoadPolicy;
+    /** Resolved URLs that failed to load this session, per editor instance. Inline
+     *  rebuild creates a fresh <img> per keystroke, which without this renders
+     *  unbroken until the async `error` re-fires — a flicker on every keystroke. */
+    brokenUrlCache: Set<string>;
+}
+export declare function buildImageWidget(node: InlineNode, _raw: string, opts: BuildImageWidgetOpts): HTMLSpanElement;

package/dist/components/image/widget-dom.js

@@ -0,0 +1,110 @@
+// The widget contributes its raw bytes via data-source-start/end, which
+// `cursor/widget-offset.ts` reads; textContent stays empty so prose
+// `textContent === ambientPrefix + raw` still holds.
+import { isAllowedImageSrcScheme } from '../../core/url-policy';
+import { findSurfacePathForElement } from '../../selection/path-lookup';
+import { devWarn } from '../../dev-warn';
+export function buildImageWidget(node, _raw, opts) {
+    const widget = document.createElement('span');
+    widget.className = 'md-image-widget';
+    // `data-inline-widget` is the shared atomic-widget marker read by the cursor
+    // walker, selection painter and raw reader; `data-image-widget` is image-specific.
+    widget.dataset.inlineWidget = '';
+    widget.dataset.imageWidget = '';
+    widget.dataset.sourceStart = String(node.start);
+    widget.dataset.sourceEnd = String(node.end);
+    widget.setAttribute('contenteditable', 'false');
+    // Select on `click`, never `pointerdown`: a pointerdown listener hijacks a gesture
+    // STARTING on the image, so no cross-block drag could originate here. Shift-click
+    // is a cross-block extension the block owns, so decline it.
+    widget.addEventListener('click', (e) => {
+        if (e.shiftKey)
+            return;
+        // Resolve the path live rather than baking it at build time: content inserted
+        // above shifts the block's path without touching its `raw`, so the render memo
+        // skips a rebuild and a baked path resolves the wrong CST node. The SURFACE door:
+        // inside a cell the block path stops at the table, whose offsets are cell indices.
+        const paragraphPath = findSurfacePathForElement(widget);
+        if (!paragraphPath)
+            return;
+        // Match TextEditableBlock.snapClickToWidgetEdge, which lands the caret at the
+        // widget's right edge, so Ctrl+Z restores the click's visual landing.
+        const event = new CustomEvent('image-widget-select', {
+            bubbles: true,
+            detail: {
+                paragraphPath,
+                sourceStart: node.start,
+                preSelectOffset: node.end
+            }
+        });
+        widget.dispatchEvent(event);
+    });
+    const img = document.createElement('img');
+    // A default-draggable <img> starts a native HTML5 drag that swallows the
+    // pointermove stream a cross-block drag needs.
+    img.draggable = false;
+    img.alt = node.alt ?? '';
+    const resolvedUrl = safeResolve(opts.resolveImageUrl, node.url ?? '');
+    const policy = opts.imageLoadPolicy ?? 'auto';
+    if (!isAllowedImageSrcScheme(resolvedUrl)) {
+        widget.classList.add('md-image-blocked');
+    }
+    else if (policy === 'placeholder') {
+        widget.classList.add('md-image-placeholder');
+    }
+    else {
+        img.src = resolvedUrl;
+    }
+    if (node.title)
+        img.title = node.title;
+    if (node.width !== undefined)
+        img.setAttribute('width', String(node.width));
+    if (node.height !== undefined)
+        img.setAttribute('height', String(node.height));
+    // A declared `|WxH` box belongs to the author, so it both reserves space before the bytes
+    // arrive and survives the decode: the attribute pair alone loses to the natural ratio the
+    // moment `height: auto` has one to read.
+    if (node.width !== undefined && node.height !== undefined) {
+        img.style.aspectRatio = `${node.width} / ${node.height}`;
+    }
+    const markBroken = () => {
+        opts.brokenUrlCache.add(resolvedUrl);
+        widget.classList.add('md-image-broken');
+    };
+    // Broken means the request finished and produced nothing to lay out, so each site
+    // establishes completion itself: `complete` here, by definition in the load listener.
+    const hasNoIntrinsicSize = () => img.naturalWidth === 0;
+    // Only a loaded image can be broken: a blocked/placeholder widget leaves src unset,
+    // and an unset <img> reports complete && naturalWidth === 0 in a real browser.
+    if (img.src && (opts.brokenUrlCache.has(resolvedUrl) || (img.complete && hasNoIntrinsicSize()))) {
+        markBroken();
+    }
+    img.addEventListener('error', markBroken);
+    // A load event is not proof of success: a 200 the decoder cannot size (truncated
+    // body, an SVG with no intrinsic dimensions) fires `load` with naturalWidth 0, and
+    // deferring that to the next rebuild leaves the placeholder a render behind.
+    img.addEventListener('load', () => {
+        if (hasNoIntrinsicSize()) {
+            markBroken();
+            return;
+        }
+        opts.brokenUrlCache.delete(resolvedUrl);
+        widget.classList.remove('md-image-broken');
+    });
+    widget.appendChild(img);
+    return widget;
+}
+function safeResolve(resolver, url) {
+    try {
+        const out = resolver(url);
+        if (typeof out !== 'string') {
+            devWarn('image-widget', 'resolveImageUrl returned non-string; falling back to raw URL');
+            return url;
+        }
+        return out;
+    }
+    catch (e) {
+        devWarn('image-widget', 'resolveImageUrl threw', e);
+        return url;
+    }
+}

package/dist/components/image/widget-selection-state.svelte.d.ts

@@ -0,0 +1,18 @@
+/** What an outside-press dismiss handler must NOT treat as outside: the widget itself and
+ *  the overlay chrome anchored to it. One string, because both handlers must move together. */
+export declare const IMAGE_CHROME_SELECTOR = "[data-image-widget], [data-image-overlay]";
+export interface WidgetTarget {
+    paragraphPath: number[];
+    sourceStart: number;
+    preSelectOffset: number;
+}
+export interface WidgetSelectionState {
+    getSelected(): WidgetTarget | null;
+    select(target: WidgetTarget): void;
+    clear(): void;
+    isSelected(paragraphPath: number[], sourceStart: number): boolean;
+}
+export interface CreateWidgetSelectionOpts {
+    onSelect: () => void;
+}
+export declare function createWidgetSelectionState(opts: CreateWidgetSelectionOpts): WidgetSelectionState;

package/dist/components/image/widget-selection-state.svelte.js

@@ -0,0 +1,26 @@
+// Image-widget selection is mutually exclusive with caret and cross-block
+// selection; `select` fires `onSelect` so the editor shell can clear the others.
+import { pathsEqual } from '../../selection/path-math';
+/** What an outside-press dismiss handler must NOT treat as outside: the widget itself and
+ *  the overlay chrome anchored to it. One string, because both handlers must move together. */
+export const IMAGE_CHROME_SELECTOR = '[data-image-widget], [data-image-overlay]';
+export function createWidgetSelectionState(opts) {
+    let selected = $state(null);
+    return {
+        getSelected: () => selected,
+        select: (target) => {
+            selected = {
+                paragraphPath: [...target.paragraphPath],
+                sourceStart: target.sourceStart,
+                preSelectOffset: target.preSelectOffset
+            };
+            opts.onSelect();
+        },
+        clear: () => {
+            selected = null;
+        },
+        isSelected: (path, start) => selected !== null &&
+            selected.sourceStart === start &&
+            pathsEqual(selected.paragraphPath, path)
+    };
+}