@nuraly/lumenjs 0.1.2 → 0.1.4

package/dist/permissions/tables.js

@@ -0,0 +1,68 @@
+/**
+ * Auto-create permission tables in the LumenJS SQLite database.
+ * Follows the same pattern as ensureUsersTable() in auth/native-auth.ts.
+ */
+export async function ensurePermissionTables(db) {
+    if (db.isPg)
+        return;
+    await db.exec(`
+    CREATE TABLE IF NOT EXISTS _nk_resource_permissions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      resource_type TEXT NOT NULL,
+      resource_id TEXT NOT NULL,
+      grantee_type TEXT NOT NULL CHECK (grantee_type IN ('user', 'role', 'public', 'anonymous')),
+      grantee_id TEXT NOT NULL DEFAULT '',
+      permission TEXT NOT NULL,
+      granted_by TEXT,
+      expires_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(resource_type, resource_id, grantee_type, grantee_id, permission)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_nk_rp_resource
+      ON _nk_resource_permissions(resource_type, resource_id);
+    CREATE INDEX IF NOT EXISTS idx_nk_rp_grantee
+      ON _nk_resource_permissions(grantee_type, grantee_id);
+
+    CREATE TABLE IF NOT EXISTS _nk_roles (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      permissions TEXT NOT NULL DEFAULT '[]',
+      hierarchy INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS _nk_user_roles (
+      user_id TEXT NOT NULL,
+      role_id TEXT NOT NULL,
+      resource_type TEXT NOT NULL DEFAULT '',
+      resource_id TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (user_id, role_id, resource_type, resource_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_nk_ur_user
+      ON _nk_user_roles(user_id);
+
+    CREATE TABLE IF NOT EXISTS _nk_permission_audit_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      action TEXT NOT NULL,
+      resource_type TEXT,
+      resource_id TEXT,
+      grantee_type TEXT,
+      grantee_id TEXT,
+      permission TEXT,
+      role_id TEXT,
+      actor_id TEXT NOT NULL,
+      details TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_nk_pal_resource
+      ON _nk_permission_audit_log(resource_type, resource_id);
+    CREATE INDEX IF NOT EXISTS idx_nk_pal_actor
+      ON _nk_permission_audit_log(actor_id);
+    CREATE INDEX IF NOT EXISTS idx_nk_pal_created
+      ON _nk_permission_audit_log(created_at);
+  `);
+}

package/dist/permissions/types.d.ts

@@ -0,0 +1,33 @@
+export interface ResourcePermission {
+    id: number;
+    resource_type: string;
+    resource_id: string;
+    grantee_type: 'user' | 'role' | 'public' | 'anonymous';
+    grantee_id: string | null;
+    permission: string;
+    granted_by: string | null;
+    expires_at: string | null;
+    created_at: string;
+}
+export interface Role {
+    id: string;
+    name: string;
+    permissions: string[];
+    hierarchy: number;
+    created_at: string;
+}
+export interface UserRole {
+    user_id: string;
+    role_id: string;
+    resource_type: string | null;
+    resource_id: string | null;
+    created_at: string;
+}
+export interface PermissionsConfig {
+    enabled?: boolean;
+    defaultOwnerGrants?: string[];
+}
+export interface ResolvedPermissionsConfig {
+    enabled: boolean;
+    defaultOwnerGrants: string[];
+}

package/dist/permissions/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/app-shell.js

@@ -1,5 +1,146 @@
 import { routes } from 'virtual:lumenjs-routes';
 import { NkRouter } from './router.js';
+function getDefaultStrategy() {
+    const el = document.getElementById('__nk_prefetch__');
+    if (el) {
+        const val = el.textContent?.trim();
+        if (val === 'hover' || val === 'viewport' || val === 'none')
+            return val;
+    }
+    return 'hover';
+}
+function getAnchorHref(anchor) {
+    const href = anchor.getAttribute('href');
+    if (!href || href.startsWith('http') || href.startsWith('#') || anchor.hasAttribute('target'))
+        return null;
+    return href;
+}
+function getLinkStrategy(anchor, defaultStrategy) {
+    const override = anchor.dataset.prefetch;
+    if (override === 'hover' || override === 'viewport' || override === 'none')
+        return override;
+    return defaultStrategy;
+}
+function setupPrefetchObserver(defaultStrategy) {
+    const prefetched = new Set();
+    const doPrefetch = (href) => {
+        if (prefetched.has(href))
+            return;
+        prefetched.add(href);
+        const pf = window.__nk_prefetch;
+        if (pf)
+            pf(href);
+    };
+    // Hover strategy: event delegation on document
+    if (defaultStrategy === 'hover' || defaultStrategy === 'viewport') {
+        const onPointerEnter = (e) => {
+            const path = e.composedPath();
+            const anchor = path.find(el => el instanceof HTMLElement && el.tagName === 'A');
+            if (!anchor)
+                return;
+            const href = getAnchorHref(anchor);
+            if (!href)
+                return;
+            const strategy = getLinkStrategy(anchor, defaultStrategy);
+            if (strategy === 'none')
+                return;
+            if (strategy === 'hover')
+                doPrefetch(href);
+        };
+        document.addEventListener('pointerenter', onPointerEnter, true);
+        document.addEventListener('focusin', (e) => {
+            const target = e.target;
+            if (target instanceof HTMLAnchorElement) {
+                const href = getAnchorHref(target);
+                if (!href)
+                    return;
+                const strategy = getLinkStrategy(target, defaultStrategy);
+                if (strategy === 'none')
+                    return;
+                if (strategy === 'hover')
+                    doPrefetch(href);
+            }
+        });
+    }
+    // Viewport strategy: IntersectionObserver for links
+    if (defaultStrategy === 'viewport') {
+        const observedLinks = new WeakSet();
+        const io = new IntersectionObserver((entries) => {
+            for (const entry of entries) {
+                if (!entry.isIntersecting)
+                    continue;
+                const anchor = entry.target;
+                const href = getAnchorHref(anchor);
+                if (!href)
+                    continue;
+                const strategy = getLinkStrategy(anchor, defaultStrategy);
+                if (strategy === 'none' || strategy === 'hover')
+                    continue;
+                doPrefetch(href);
+                io.unobserve(anchor);
+            }
+        }, { rootMargin: '200px' });
+        const observeLinks = (root) => {
+            const anchors = root.querySelectorAll('a[href]');
+            for (const a of anchors) {
+                const anchor = a;
+                if (observedLinks.has(anchor))
+                    continue;
+                const href = getAnchorHref(anchor);
+                if (!href)
+                    continue;
+                const strategy = getLinkStrategy(anchor, defaultStrategy);
+                if (strategy !== 'viewport')
+                    continue;
+                observedLinks.add(anchor);
+                io.observe(anchor);
+            }
+            // Walk shadow roots to find links inside web components
+            const els = root.querySelectorAll('*');
+            for (const el of els) {
+                if (el.shadowRoot)
+                    observeLinks(el.shadowRoot);
+            }
+        };
+        const observeShadowRoot = (sr) => {
+            observeLinks(sr);
+            const smo = new MutationObserver(() => observeLinks(sr));
+            smo.observe(sr, { childList: true, subtree: true });
+        };
+        // Observe existing links after initial render (including shadow roots)
+        requestAnimationFrame(() => {
+            observeLinks(document);
+            // Also observe shadow roots of existing elements
+            document.querySelectorAll('*').forEach(el => {
+                if (el.shadowRoot)
+                    observeShadowRoot(el.shadowRoot);
+            });
+        });
+        // Watch for dynamically added links and new shadow roots
+        const mo = new MutationObserver((mutations) => {
+            for (const mutation of mutations) {
+                for (const node of mutation.addedNodes) {
+                    if (node instanceof HTMLElement) {
+                        if (node.tagName === 'A') {
+                            observeLinks(node.parentElement || document);
+                        }
+                        else {
+                            observeLinks(node);
+                            if (node.shadowRoot)
+                                observeShadowRoot(node.shadowRoot);
+                        }
+                        // Check children for shadow roots
+                        node.querySelectorAll?.('*').forEach(child => {
+                            if (child.shadowRoot)
+                                observeShadowRoot(child.shadowRoot);
+                        });
+                    }
+                }
+            }
+        });
+        mo.observe(document.body, { childList: true, subtree: true });
+    }
+}
 /**
  * <nk-app> — The application shell. Sets up the router and renders pages.
  */
@@ -14,7 +155,29 @@ class NkApp extends HTMLElement {
             this.innerHTML = '<div id="nk-router-outlet"></div>';
         }
         const outlet = this.querySelector('#nk-router-outlet');
+        // Create route announcer for screen readers (WCAG 2.4.2)
+        const announcer = document.createElement('div');
+        announcer.id = 'nk-route-announcer';
+        announcer.setAttribute('aria-live', 'assertive');
+        announcer.setAttribute('aria-atomic', 'true');
+        announcer.setAttribute('role', 'status');
+        Object.assign(announcer.style, {
+            position: 'absolute',
+            width: '1px',
+            height: '1px',
+            padding: '0',
+            margin: '-1px',
+            overflow: 'hidden',
+            clip: 'rect(0,0,0,0)',
+            whiteSpace: 'nowrap',
+            border: '0',
+        });
+        this.appendChild(announcer);
         this.router = new NkRouter(routes, outlet, isSSR);
+        const strategy = getDefaultStrategy();
+        if (strategy !== 'none') {
+            setupPrefetchObserver(strategy);
+        }
     }
 }
 if (!customElements.get('nk-app')) {

package/dist/runtime/auth.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Client-side auth store — singleton following the i18n.ts pattern.
+ * Hydrated from __nk_auth__ script tag on page load.
+ */
+export declare function getUser(): any;
+export declare function isAuthenticated(): boolean;
+export declare function hasRole(role: string): boolean;
+export declare function initAuth(user: any): void;
+export declare function login(returnTo?: string): void;
+export declare function logout(): void;

package/dist/runtime/auth.js

@@ -0,0 +1,30 @@
+/**
+ * Client-side auth store — singleton following the i18n.ts pattern.
+ * Hydrated from __nk_auth__ script tag on page load.
+ */
+let currentUser = null;
+let initialized = false;
+export function getUser() {
+    return currentUser;
+}
+export function isAuthenticated() {
+    return currentUser !== null;
+}
+export function hasRole(role) {
+    return currentUser?.roles?.includes(role) ?? false;
+}
+export function initAuth(user) {
+    currentUser = user;
+    initialized = true;
+}
+export function login(returnTo) {
+    const url = new URL('/__nk_auth/login', location.origin);
+    if (returnTo)
+        url.searchParams.set('returnTo', returnTo);
+    location.href = url.toString();
+}
+export function logout() {
+    currentUser = null;
+    initialized = false;
+    location.href = '/__nk_auth/logout';
+}

package/dist/runtime/communication.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Client-side communication SDK.
+ * Connects to the server via Socket.io and provides a clean API for chat, typing, and presence.
+ */
+/**
+ * Connect to the communication socket.
+ * Must be called before using any other functions.
+ */
+export declare function connectChat(params?: Record<string, string>): Promise<void>;
+/** Join a conversation room to receive messages */
+export declare function joinConversation(conversationId: string): void;
+/** Leave a conversation room */
+export declare function leaveConversation(conversationId: string): void;
+/** Send a message */
+export declare function sendMessage(conversationId: string, content: string, type?: string): void;
+/** Mark a message as read */
+export declare function markRead(conversationId: string, messageId: string): void;
+/** React to a message with an emoji (toggle) */
+export declare function reactToMessage(messageId: string, conversationId: string, emoji: string): void;
+/** Edit a message */
+export declare function editMessage(messageId: string, conversationId: string, content: string): void;
+/** Delete a message */
+export declare function deleteMessage(messageId: string, conversationId: string): void;
+/** Listen for reaction updates */
+export declare function onReactionUpdate(handler: (data: {
+    messageId: string;
+    reactions: any[];
+}) => void): () => void;
+/** Listen for message edits */
+export declare function onMessageUpdated(handler: (data: {
+    messageId: string;
+    content: string;
+    updatedAt: string;
+}) => void): () => void;
+/** Listen for message deletions */
+export declare function onMessageDeleted(handler: (data: {
+    messageId: string;
+    conversationId: string;
+}) => void): () => void;
+/** Upload a file (returns attachment metadata) */
+export declare function uploadFile(file: Blob, filename: string, encrypted?: boolean): Promise<{
+    id: string;
+    url: string;
+    size: number;
+}>;
+/** Fetch link previews for a text */
+export declare function fetchLinkPreviews(text: string): Promise<any[]>;
+/** Start typing indicator */
+export declare function startTyping(conversationId: string): void;
+/** Stop typing indicator */
+export declare function stopTyping(conversationId: string): void;
+/** Update presence status */
+export declare function updatePresence(status: 'online' | 'offline' | 'away' | 'busy'): void;
+/** Listen for new messages */
+export declare function onMessage(handler: (message: any) => void): () => void;
+/** Listen for typing updates */
+export declare function onTyping(handler: (data: {
+    conversationId: string;
+    userId: string;
+    isTyping: boolean;
+}) => void): () => void;
+/** Listen for presence changes */
+export declare function onPresence(handler: (data: {
+    userId: string;
+    status: string;
+    lastSeen: string;
+}) => void): () => void;
+/** Listen for read receipts */
+export declare function onReadReceipt(handler: (data: any) => void): () => void;
+/** Listen for incoming calls */
+export declare function onIncomingCall(handler: (call: any) => void): () => void;
+/** Listen for call state changes (initiating, ringing, connecting, connected, ended) */
+export declare function onCallStateChanged(handler: (data: {
+    callId: string;
+    state: string;
+    endReason?: string;
+}) => void): () => void;
+/** Listen for participants joining a call */
+export declare function onParticipantJoined(handler: (data: {
+    callId: string;
+    participant: any;
+}) => void): () => void;
+/** Listen for participants leaving a call */
+export declare function onParticipantLeft(handler: (data: {
+    callId: string;
+    userId: string;
+}) => void): () => void;
+/** Listen for media changes (mute/unmute/screenshare) */
+export declare function onMediaChanged(handler: (data: {
+    callId: string;
+    userId: string;
+    audio?: boolean;
+    video?: boolean;
+    screenShare?: boolean;
+}) => void): () => void;
+/** Initiate an audio or video call */
+export declare function initiateCall(conversationId: string, type: 'audio' | 'video', calleeIds: string[]): void;
+/** Respond to an incoming call */
+export declare function respondToCall(callId: string, action: 'accept' | 'reject'): void;
+/** Hang up an active call */
+export declare function hangup(callId: string, reason?: string): void;
+/** Toggle audio/video/screenshare during a call */
+export declare function toggleMedia(callId: string, opts: {
+    audio?: boolean;
+    video?: boolean;
+    screenShare?: boolean;
+}): void;
+/** Send SDP offer to a peer */
+export declare function sendOffer(callId: string, toUserId: string, sdp: string): void;
+/** Send SDP answer to a peer */
+export declare function sendAnswer(callId: string, toUserId: string, sdp: string): void;
+/** Send ICE candidate to a peer */
+export declare function sendIceCandidate(callId: string, toUserId: string, candidate: string, sdpMLineIndex: number | null, sdpMid: string | null): void;
+/** Listen for SDP offers from peers */
+export declare function onSignalOffer(handler: (data: {
+    callId: string;
+    fromUserId: string;
+    sdp: string;
+}) => void): () => void;
+/** Listen for SDP answers from peers */
+export declare function onSignalAnswer(handler: (data: {
+    callId: string;
+    fromUserId: string;
+    sdp: string;
+}) => void): () => void;
+/** Listen for ICE candidates from peers */
+export declare function onIceCandidate(handler: (data: {
+    callId: string;
+    fromUserId: string;
+    candidate: string;
+    sdpMLineIndex: number | null;
+    sdpMid: string | null;
+}) => void): () => void;
+/** Disconnect from communication socket */
+export declare function disconnect(): void;
+/** Check if connected */
+export declare function isConnected(): boolean;

package/dist/runtime/communication.js

@@ -0,0 +1,228 @@
+/**
+ * Client-side communication SDK.
+ * Connects to the server via Socket.io and provides a clean API for chat, typing, and presence.
+ */
+let _socket = null;
+let _handlers = new Map();
+function emit(event, data) {
+    if (!_socket)
+        throw new Error('Communication not connected. Call connectChat() first.');
+    _socket.emit(`nk:${event}`, data);
+}
+function addHandler(event, handler) {
+    let set = _handlers.get(event);
+    if (!set) {
+        set = new Set();
+        _handlers.set(event, set);
+    }
+    set.add(handler);
+}
+function removeHandler(event, handler) {
+    _handlers.get(event)?.delete(handler);
+}
+/**
+ * Connect to the communication socket.
+ * Must be called before using any other functions.
+ */
+export async function connectChat(params) {
+    if (_socket)
+        return;
+    const { io } = await import('socket.io-client');
+    _socket = io('/nk/messages', {
+        path: '/__nk_socketio/',
+        query: { ...params, __params: JSON.stringify(params || {}) },
+    });
+    _socket.on('nk:data', (data) => {
+        if (data?.event) {
+            const handlers = _handlers.get(data.event);
+            if (handlers) {
+                for (const h of handlers)
+                    h(data.data);
+            }
+        }
+    });
+}
+/** Join a conversation room to receive messages */
+export function joinConversation(conversationId) {
+    emit('conversation:join', { conversationId });
+}
+/** Leave a conversation room */
+export function leaveConversation(conversationId) {
+    emit('conversation:leave', { conversationId });
+}
+/** Send a message */
+export function sendMessage(conversationId, content, type = 'text') {
+    emit('message:send', { conversationId, content, type });
+}
+/** Mark a message as read */
+export function markRead(conversationId, messageId) {
+    emit('message:read', { conversationId, messageId });
+}
+/** React to a message with an emoji (toggle) */
+export function reactToMessage(messageId, conversationId, emoji) {
+    emit('message:react', { messageId, conversationId, emoji });
+}
+/** Edit a message */
+export function editMessage(messageId, conversationId, content) {
+    emit('message:edit', { messageId, conversationId, content });
+}
+/** Delete a message */
+export function deleteMessage(messageId, conversationId) {
+    emit('message:delete', { messageId, conversationId });
+}
+/** Listen for reaction updates */
+export function onReactionUpdate(handler) {
+    addHandler('message:reaction-update', handler);
+    return () => removeHandler('message:reaction-update', handler);
+}
+/** Listen for message edits */
+export function onMessageUpdated(handler) {
+    addHandler('message:updated', handler);
+    return () => removeHandler('message:updated', handler);
+}
+/** Listen for message deletions */
+export function onMessageDeleted(handler) {
+    addHandler('message:deleted', handler);
+    return () => removeHandler('message:deleted', handler);
+}
+/** Upload a file (returns attachment metadata) */
+export async function uploadFile(file, filename, encrypted = false) {
+    const res = await fetch('/__nk_comm/upload', {
+        method: 'POST',
+        headers: {
+            'Content-Type': file.type || 'application/octet-stream',
+            'X-Filename': filename,
+            ...(encrypted ? { 'X-Encrypted': '1' } : {}),
+        },
+        body: file,
+    });
+    if (!res.ok)
+        throw new Error(`Upload failed: ${res.status}`);
+    return res.json();
+}
+/** Fetch link previews for a text */
+export async function fetchLinkPreviews(text) {
+    const res = await fetch('/__nk_comm/link-preview', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ text }),
+    });
+    if (!res.ok)
+        return [];
+    const data = await res.json();
+    return data.previews || [];
+}
+/** Start typing indicator */
+export function startTyping(conversationId) {
+    emit('typing:start', { conversationId });
+}
+/** Stop typing indicator */
+export function stopTyping(conversationId) {
+    emit('typing:stop', { conversationId });
+}
+/** Update presence status */
+export function updatePresence(status) {
+    emit('presence:update', { status });
+}
+/** Listen for new messages */
+export function onMessage(handler) {
+    addHandler('message:new', handler);
+    return () => removeHandler('message:new', handler);
+}
+/** Listen for typing updates */
+export function onTyping(handler) {
+    addHandler('typing:update', handler);
+    return () => removeHandler('typing:update', handler);
+}
+/** Listen for presence changes */
+export function onPresence(handler) {
+    addHandler('presence:changed', handler);
+    return () => removeHandler('presence:changed', handler);
+}
+/** Listen for read receipts */
+export function onReadReceipt(handler) {
+    addHandler('read-receipt:update', handler);
+    return () => removeHandler('read-receipt:update', handler);
+}
+// ── Calls ─────────────────────────────────────────────────────────
+/** Listen for incoming calls */
+export function onIncomingCall(handler) {
+    addHandler('call:incoming', handler);
+    return () => removeHandler('call:incoming', handler);
+}
+/** Listen for call state changes (initiating, ringing, connecting, connected, ended) */
+export function onCallStateChanged(handler) {
+    addHandler('call:state-changed', handler);
+    return () => removeHandler('call:state-changed', handler);
+}
+/** Listen for participants joining a call */
+export function onParticipantJoined(handler) {
+    addHandler('call:participant-joined', handler);
+    return () => removeHandler('call:participant-joined', handler);
+}
+/** Listen for participants leaving a call */
+export function onParticipantLeft(handler) {
+    addHandler('call:participant-left', handler);
+    return () => removeHandler('call:participant-left', handler);
+}
+/** Listen for media changes (mute/unmute/screenshare) */
+export function onMediaChanged(handler) {
+    addHandler('call:media-changed', handler);
+    return () => removeHandler('call:media-changed', handler);
+}
+/** Initiate an audio or video call */
+export function initiateCall(conversationId, type, calleeIds) {
+    emit('call:initiate', { conversationId, type, calleeIds });
+}
+/** Respond to an incoming call */
+export function respondToCall(callId, action) {
+    emit('call:respond', { callId, action });
+}
+/** Hang up an active call */
+export function hangup(callId, reason = 'completed') {
+    emit('call:hangup', { callId, reason });
+}
+/** Toggle audio/video/screenshare during a call */
+export function toggleMedia(callId, opts) {
+    emit('call:media-toggle', { callId, ...opts });
+}
+// ── WebRTC Signaling ──────────────────────────────────────────────
+/** Send SDP offer to a peer */
+export function sendOffer(callId, toUserId, sdp) {
+    emit('signal:offer', { callId, fromUserId: '', toUserId, type: 'offer', sdp });
+}
+/** Send SDP answer to a peer */
+export function sendAnswer(callId, toUserId, sdp) {
+    emit('signal:answer', { callId, fromUserId: '', toUserId, type: 'answer', sdp });
+}
+/** Send ICE candidate to a peer */
+export function sendIceCandidate(callId, toUserId, candidate, sdpMLineIndex, sdpMid) {
+    emit('signal:ice-candidate', { callId, fromUserId: '', toUserId, candidate, sdpMLineIndex, sdpMid });
+}
+/** Listen for SDP offers from peers */
+export function onSignalOffer(handler) {
+    addHandler('signal:offer', handler);
+    return () => removeHandler('signal:offer', handler);
+}
+/** Listen for SDP answers from peers */
+export function onSignalAnswer(handler) {
+    addHandler('signal:answer', handler);
+    return () => removeHandler('signal:answer', handler);
+}
+/** Listen for ICE candidates from peers */
+export function onIceCandidate(handler) {
+    addHandler('signal:ice-candidate', handler);
+    return () => removeHandler('signal:ice-candidate', handler);
+}
+/** Disconnect from communication socket */
+export function disconnect() {
+    if (_socket) {
+        _socket.disconnect();
+        _socket = null;
+        _handlers.clear();
+    }
+}
+/** Check if connected */
+export function isConnected() {
+    return _socket?.connected ?? false;
+}