@satinhq/kit 0.0.0-stage → 0.1.0-beta.0

package/dist/app/launchScreenRuntime.js

@@ -0,0 +1,313 @@
+// Serialized into the head so failures before module loading use the same
+// controller as ordinary readiness. Keep this function self-contained.
+export function installLaunchScreenRuntime() {
+    const launchWindow = window;
+    if (launchWindow.__SATIN_LAUNCH_SCREEN__)
+        return launchWindow.__SATIN_LAUNCH_SCREEN__;
+    let value = 0;
+    let velocity = 0;
+    let target = 0;
+    let downloadTarget = 0;
+    let frame = 0;
+    let previous = 0;
+    let generation = 0;
+    let revealed = false;
+    const alignCover = () => {
+        if (revealed)
+            return;
+        const standalone = navigator.standalone === true;
+        const fullWidth = Math.abs(innerWidth - screen.width) <= 1;
+        // Default-status-bar WebClips start their viewport below the system strip.
+        // Extend the cover into that excluded space so its center stays in the
+        // native startup image's screen frame. Windowed apps keep their own frame.
+        const excludedTop = standalone && fullWidth ? Math.max(0, screen.height - innerHeight) : 0;
+        document.documentElement.style.setProperty('--satin-launch-excluded-top', `${excludedTop}px`);
+    };
+    alignCover();
+    window.addEventListener('resize', alignCover);
+    window.addEventListener('orientationchange', alignCover);
+    window.addEventListener('satin-launch-revealed', () => {
+        window.removeEventListener('resize', alignCover);
+        window.removeEventListener('orientationchange', alignCover);
+    }, { once: true });
+    let retiring = null;
+    let appliedUpdate = null;
+    let updateAnimation = null;
+    const ringElement = () => document.getElementById('satin-launch-progress');
+    const paint = () => {
+        ringElement()
+            ?.querySelector('circle')
+            ?.setAttribute('stroke-dashoffset', String(100 - Math.max(0, Math.min(100, value))));
+    };
+    const animateProgress = (now) => {
+        const seconds = Math.min((now - previous) / 1000, 0.032);
+        previous = now;
+        // Existing measured spring: mass 1, stiffness 186.57, damping 25.13.
+        const steps = Math.max(1, Math.ceil(seconds / 0.004));
+        for (let index = 0; index < steps; index++) {
+            const dt = seconds / steps;
+            velocity += ((target - value) * 186.57 - velocity * 25.13) * dt;
+            value += velocity * dt;
+        }
+        if (Math.abs(target - value) > 0.01 || Math.abs(velocity) > 0.01) {
+            frame = requestAnimationFrame(animateProgress);
+        }
+        else {
+            value = target;
+            velocity = 0;
+            frame = 0;
+        }
+        paint();
+        ringElement()?.setAttribute('aria-valuenow', String(Math.round(value)));
+    };
+    const start = () => {
+        if (frame)
+            return;
+        previous = performance.now();
+        frame = requestAnimationFrame(animateProgress);
+    };
+    const complete = () => {
+        if (appliedUpdate)
+            return appliedUpdate;
+        const ring = ringElement();
+        if (!ring || ring.hasAttribute('hidden'))
+            return Promise.resolve(true);
+        const currentGeneration = generation;
+        // This is presentation completion, not a synthetic download-byte event.
+        target = 100;
+        start();
+        return new Promise(resolve => {
+            const check = () => {
+                if (currentGeneration !== generation) {
+                    resolve(false);
+                    return;
+                }
+                if (frame)
+                    requestAnimationFrame(check);
+                // Let the exact full arc paint before fading or replacing the document.
+                else
+                    requestAnimationFrame(() => requestAnimationFrame(() => resolve(currentGeneration === generation)));
+            };
+            check();
+        });
+    };
+    const fade = async (element, duration) => {
+        await element
+            .animate([{ opacity: 1 }, { opacity: 0 }], {
+            duration,
+            easing: 'ease-out',
+            fill: 'forwards',
+        })
+            .finished.catch(() => { });
+    };
+    const retire = (onRetired) => {
+        const screen = document.getElementById('satin-launch-screen');
+        if (!screen) {
+            onRetired();
+            return;
+        }
+        const currentGeneration = generation;
+        retiring ??= (async () => {
+            const ring = ringElement();
+            if (ring && !ring.hasAttribute('hidden')) {
+                // React and head failure panels must stay behind the completing arc.
+                screen.style.zIndex = '20003';
+                ring.setAttribute('aria-label', 'Finishing launch');
+                await complete();
+                if (currentGeneration !== generation)
+                    return;
+                await fade(ring, 200);
+                if (currentGeneration !== generation)
+                    return;
+                ring.setAttribute('hidden', '');
+            }
+            if (currentGeneration !== generation)
+                return;
+            await fade(screen, 300);
+            if (currentGeneration !== generation)
+                return;
+            screen.hidden = true;
+            performance.mark('satin-launch-cover-retired');
+        })();
+        void retiring.then(() => {
+            if (currentGeneration === generation)
+                onRetired();
+        });
+    };
+    const controller = {
+        updated(start = 0) {
+            if (appliedUpdate)
+                return appliedUpdate;
+            const ring = ringElement();
+            const circle = ring?.querySelector('circle');
+            if (!ring || !circle || revealed || retiring)
+                return Promise.resolve(false);
+            const currentGeneration = generation;
+            cancelAnimationFrame(frame);
+            frame = 0;
+            value = start;
+            velocity = 0;
+            target = downloadTarget = 100;
+            paint();
+            ring.removeAttribute('hidden');
+            ring.setAttribute('aria-label', 'App updated');
+            ring.setAttribute('aria-valuenow', String(start));
+            // Owner-requested confirmation, not download bytes or a native motion fit.
+            const animation = circle.animate([{ strokeDashoffset: String(100 - start) }, { strokeDashoffset: '0' }], { duration: 800, easing: 'ease-in-out', fill: 'forwards' });
+            updateAnimation = animation;
+            const visibilityChanged = () => (document.hidden ? animation.pause() : animation.play());
+            document.addEventListener('visibilitychange', visibilityChanged);
+            visibilityChanged();
+            appliedUpdate = animation.finished
+                .then(() => {
+                if (currentGeneration !== generation)
+                    return false;
+                value = 100;
+                paint();
+                ring.setAttribute('aria-valuenow', '100');
+                animation.cancel();
+                return true;
+            }, () => false)
+                .finally(() => {
+                document.removeEventListener('visibilitychange', visibilityChanged);
+                if (updateAnimation === animation)
+                    updateAnimation = null;
+            });
+            return appliedUpdate;
+        },
+        progress(progress) {
+            const ring = ringElement();
+            // A phase ending does not mean the cover is ready to retire. Keep the
+            // real last sample until readiness or an explicit error owns the handoff.
+            if (!ring || revealed || retiring || !progress || progress.total <= 0)
+                return;
+            if (!Number.isFinite(progress.loaded) || !Number.isFinite(progress.total))
+                return;
+            const next = Math.max(0, Math.min(100, (progress.loaded / progress.total) * 100));
+            // Bundle preparation and update checking may have different denominators.
+            // A visible arc never jumps backwards when the next phase starts.
+            downloadTarget = Math.max(downloadTarget, next);
+            target = downloadTarget;
+            ring.removeAttribute('hidden');
+            ring.setAttribute('aria-label', 'Downloading and installing app');
+            start();
+        },
+        complete,
+        reveal() {
+            if (revealed)
+                return;
+            revealed = true;
+            window.dispatchEvent(new Event('satin-launch-revealed'));
+            retire(() => { });
+        },
+        fail(onRetired) {
+            retire(onRetired);
+        },
+        restore() {
+            if (revealed)
+                return;
+            // The parser starts confirmation before React mounts. Its initial restore
+            // must leave that animation running; an actual failed retirement can retry.
+            if (appliedUpdate && !retiring)
+                return;
+            updateAnimation?.cancel();
+            appliedUpdate = null;
+            generation++;
+            retiring = null;
+            // Recovery resumes the real sample through the same velocity-continuous
+            // spring, rather than leaving a cancelled completion targeted at 100.
+            target = downloadTarget;
+            const ring = ringElement();
+            const cover = document.getElementById('satin-launch-screen');
+            if (ring && !ring.hasAttribute('hidden'))
+                start();
+            for (const [element, duration] of [
+                [ring, 200],
+                [cover, 300],
+            ]) {
+                if (!element)
+                    continue;
+                const opacity = Number(getComputedStyle(element).opacity);
+                element.getAnimations().forEach(animation => animation.cancel());
+                if (Number.isFinite(opacity) && opacity < 1 && !element.hidden) {
+                    void element
+                        .animate([{ opacity }, { opacity: 1 }], {
+                        duration,
+                        easing: 'ease-out',
+                        fill: 'forwards',
+                    })
+                        .finished.catch(() => { });
+                }
+            }
+            const screen = document.getElementById('satin-launch-screen');
+            if (screen) {
+                screen.hidden = false;
+                screen.style.removeProperty('z-index');
+            }
+        },
+    };
+    launchWindow.__SATIN_LAUNCH_SCREEN__ = controller;
+    return controller;
+}
+export function setLaunchScreen(visible) {
+    if (visible) {
+        installLaunchScreenRuntime().restore();
+        return;
+    }
+    installLaunchScreenRuntime().reveal();
+}
+export function setLaunchProgress(progress) {
+    window.dispatchEvent(new CustomEvent('satin-launch-progress', { detail: progress }));
+    installLaunchScreenRuntime().progress(progress);
+}
+/** Complete a visible arc before a cold-update document replacement. */
+export function completeLaunchProgress() {
+    if (typeof document === 'undefined' || typeof document.getElementById !== 'function')
+        return Promise.resolve(true);
+    return installLaunchScreenRuntime().complete();
+}
+/** Confirm an applied update on its successor document before revealing the app. */
+export function showAppliedUpdate() {
+    return installLaunchScreenRuntime().updated();
+}
+/** Serialized after the declarative cover, before modules and their first paint. */
+export function resumeAppliedUpdate(scope, buildId) {
+    let ringStart = null;
+    try {
+        const raw = sessionStorage.getItem('satin:just-updated:v1:' + scope);
+        const marker = raw ? JSON.parse(raw) : null;
+        if (marker &&
+            Number.isFinite(marker.at) &&
+            (marker.previous === null || typeof marker.previous === 'string') &&
+            (marker.current === null || typeof marker.current === 'string')) {
+            // Legacy clients already completed their arc before requesting reload.
+            ringStart = marker.ringStart === 0 ? 0 : 100;
+        }
+    }
+    catch {
+        // A failed session-storage read must not prevent durable build detection.
+    }
+    if (buildId) {
+        const key = 'satin:revealed-build:v1:' + scope;
+        try {
+            const previous = localStorage.getItem(key);
+            // A waiting worker can activate after the old process closes, without
+            // leaving a reload marker. Compare the actual HTML build, not the network.
+            if (previous && previous !== buildId && ringStart === null)
+                ringStart = 0;
+        }
+        catch {
+            // Storage denial must not prevent the cached app from opening.
+        }
+        window.addEventListener('satin-launch-revealed', () => {
+            try {
+                localStorage.setItem(key, buildId);
+            }
+            catch {
+                // Keep the explicit reload marker path usable without durable storage.
+            }
+        }, { once: true });
+    }
+    if (ringStart !== null)
+        void window.__SATIN_LAUNCH_SCREEN__?.updated(ringStart);
+}

package/dist/app/launchWatchdog.d.ts

@@ -0,0 +1 @@
+export declare function installLaunchWatchdog(budgetMs: number): void;

package/dist/app/launchWatchdog.js

@@ -0,0 +1,202 @@
+// This function is serialized into the head. Keep it independent of module loading and React.
+export function installLaunchWatchdog(budgetMs) {
+    let idleVisibleMs = 0;
+    let previousTime = performance.now();
+    let lastBytes = 0;
+    let lastActivity = 0;
+    let revealed = false;
+    let failed = false;
+    let recordedError = '';
+    const showFailure = (reason) => {
+        if (failed || revealed)
+            return;
+        failed = true;
+        const marks = performance
+            .getEntriesByType('mark')
+            .filter(mark => mark.name.startsWith('satin-'));
+        const stage = marks.at(-1)?.name ?? 'satin-document-head';
+        console.error('[Satin launch]', reason, 'Last stage:', stage, recordedError);
+        const screen = document.createElement('section');
+        screen.id = 'satin-launch-error';
+        screen.setAttribute('role', 'alert');
+        screen.style.cssText =
+            'position:fixed;inset:0;z-index:20002;display:flex;flex-direction:column;align-items:center;justify-content:center;padding:32px;box-sizing:border-box;background:var(--satin-launch-background,#f2f2f7);color:var(--satin-launch-ink,#1c1c1e);font:17px/1.45 system-ui;text-align:center;pointer-events:auto';
+        const title = document.createElement('h1');
+        title.textContent = 'Unable to Open App';
+        title.style.cssText = 'font-size:24px;margin:0 0 12px';
+        const message = document.createElement('p');
+        message.textContent = reason;
+        message.style.maxWidth = '420px';
+        const reached = document.createElement('p');
+        reached.textContent = 'Last stage: ' + stage;
+        reached.style.cssText = 'font-size:13px;opacity:.65;overflow-wrap:anywhere';
+        const retry = document.createElement('button');
+        retry.textContent = 'Retry';
+        retry.style.cssText =
+            'font:600 17px system-ui;color:#007aff;background:transparent;border:0;padding:16px 32px;min-height:44px';
+        retry.onclick = () => {
+            const definition = window
+                .__SATIN_DEFINITION__;
+            try {
+                sessionStorage.setItem('satin-install-reset:' + (definition?.scope ?? '/'), '1');
+            }
+            catch {
+                // A reload can still join the worker after its own deadline.
+            }
+            location.reload();
+        };
+        screen.append(title, message, reached, retry);
+        (document.body ?? document.documentElement).append(screen);
+        if (!document.body) {
+            document.addEventListener('DOMContentLoaded', () => {
+                if (screen.isConnected)
+                    document.body?.append(screen);
+            }, { once: true });
+        }
+        const cover = document.getElementById('satin-launch-screen');
+        const controller = window.__SATIN_LAUNCH_SCREEN__;
+        const ring = document.getElementById('satin-launch-progress');
+        if (cover && ring && !ring.hasAttribute('hidden') && controller) {
+            // Put the failure underneath the cover until its visible arc completes.
+            screen.style.zIndex = '19999';
+            controller.fail(() => {
+                if (failed)
+                    screen.style.zIndex = '20002';
+            });
+        }
+        else if (cover)
+            cover.hidden = true;
+        performance.mark('satin-launch-failed');
+    };
+    window.addEventListener('error', event => {
+        recordedError = event.message || 'Application script failed to load.';
+    });
+    window.addEventListener('unhandledrejection', event => {
+        recordedError = event.reason instanceof Error ? event.reason.message : String(event.reason);
+    });
+    window.addEventListener('satin-glass-error', event => {
+        const error = event.detail;
+        recordedError = error.code + ': ' + error.message;
+        showFailure('Glass could not start: ' + error.code + '.');
+    });
+    const recover = () => {
+        const restoreCover = failed;
+        failed = false;
+        document.getElementById('satin-launch-error')?.remove();
+        const cover = document.getElementById('satin-launch-screen');
+        // The runtime owns normal ring settlement and cover retirement. Only undo
+        // the cover hiding performed by this watchdog's own failure screen.
+        if (cover && restoreCover) {
+            const controller = window.__SATIN_LAUNCH_SCREEN__;
+            if (controller)
+                controller.restore();
+            else
+                cover.hidden = false;
+        }
+    };
+    const receiveProgress = (progress) => {
+        if (progress && (progress.loaded > lastBytes || (progress.activity ?? 0) > lastActivity)) {
+            lastBytes = progress.loaded;
+            lastActivity = progress.activity ?? 0;
+            idleVisibleMs = 0;
+            previousTime = performance.now();
+            recover();
+        }
+        else if (!progress) {
+            lastBytes = 0;
+            lastActivity = 0;
+        }
+    };
+    window.addEventListener('satin-launch-progress', event => {
+        receiveProgress(event.detail);
+    });
+    // Keep message order when two diagnostics arrive within the same millisecond.
+    window.addEventListener('satin-worker-lookup-error', event => {
+        showFailure(String(event.detail));
+    });
+    let lastInstallationTime = 0;
+    // Listen in the head, before a bootstrap module can start downloading.
+    navigator.serviceWorker?.addEventListener('message', event => {
+        const worker = event.source;
+        const definition = window
+            .__SATIN_DEFINITION__;
+        const expected = new URL((definition?.scope ?? '/') + 'sw.js', location.href).href;
+        if (worker?.scriptURL !== expected)
+            return;
+        const progress = event.data;
+        if (progress?.type === 'SATIN_INSTALL_FAILURE') {
+            console.error('[Satin installation]', progress.url, progress.reason);
+            lastInstallationTime = Math.max(Date.now(), lastInstallationTime + 1);
+            const failure = { ...progress, recordedAt: lastInstallationTime };
+            try {
+                localStorage.setItem('satin-install-failure:' + (definition?.scope ?? '/'), JSON.stringify(failure));
+                localStorage.setItem('satin-install-failure:' + (definition?.scope ?? '/') + ':build:' + progress.buildId, JSON.stringify(failure));
+            }
+            catch {
+                /* Diagnostics remain available in the console if storage is unavailable. */
+            }
+            window.dispatchEvent(new Event('satin-install-diagnostics'));
+            // A replacement install is optional. The current scoped controller
+            // serves a successfully installed bundle even while the cover is shown.
+            const cachedController = navigator.serviceWorker?.controller;
+            if (!revealed && cachedController?.scriptURL !== expected) {
+                showFailure(progress.stalled
+                    ? 'The server stopped responding. Resource: ' + progress.url + '. Please retry.'
+                    : progress.networkFailure
+                        ? 'Check your connection and try again. Resource: ' + progress.url
+                        : 'Could not prepare ' +
+                            progress.url +
+                            ': ' +
+                            progress.reason +
+                            '. Deploy the complete matching build, then retry.');
+            }
+            return;
+        }
+        if (progress?.type === 'SATIN_INSTALL_SUCCESS' && typeof progress.buildId === 'string') {
+            lastInstallationTime = Math.max(Date.now(), lastInstallationTime + 1);
+            // Clear the previous failure even if quota prevents writing the success record.
+            try {
+                localStorage.removeItem('satin-install-failure:' + (definition?.scope ?? '/'));
+            }
+            catch {
+                /* A newer success record can still supersede a failure that could not be removed. */
+            }
+            try {
+                localStorage.setItem('satin-install-success:' + (definition?.scope ?? '/'), JSON.stringify({ buildId: progress.buildId, recordedAt: lastInstallationTime }));
+            }
+            catch {
+                /* A successful install remains usable when storage is unavailable. */
+            }
+            window.dispatchEvent(new Event('satin-install-diagnostics'));
+            return;
+        }
+        if (progress?.type === 'SATIN_DOWNLOAD_PROGRESS' &&
+            progress.downloading &&
+            Number.isFinite(progress.loaded) &&
+            progress.loaded >= 0)
+            receiveProgress(progress);
+    });
+    // A client's worker messages are queued until DOMContentLoaded, and a bootstrap module that
+    // never finishes holds DOMContentLoaded back: the worker's "this resource stalled" message
+    // would then never arrive. Open the queue now that the listener exists.
+    navigator.serviceWorker?.startMessages?.();
+    window.addEventListener('satin-launch-revealed', () => {
+        revealed = true;
+        recover();
+        clearInterval(timer);
+    });
+    document.addEventListener('visibilitychange', () => {
+        previousTime = performance.now();
+    });
+    const timer = setInterval(() => {
+        const now = performance.now();
+        if (!document.hidden)
+            idleVisibleMs += now - previousTime;
+        previousTime = now;
+        if (idleVisibleMs >= budgetMs) {
+            showFailure(recordedError
+                ? 'Launch failed. ' + recordedError.split('\n')[0].slice(0, 160)
+                : 'Launch stopped making progress. Please retry.');
+        }
+    }, 250);
+}

package/dist/app/manifests.d.ts

@@ -0,0 +1,19 @@
+import { type AppDefinition } from './definition.js';
+export declare const APP_MANIFEST_VARIANTS: readonly [{
+    readonly suffix: '.webmanifest';
+    readonly idiom: 'phone';
+    readonly selected: true;
+}, {
+    readonly suffix: '-dark.webmanifest';
+    readonly idiom: 'phone';
+    readonly selected: false;
+}, {
+    readonly suffix: '-ipad.webmanifest';
+    readonly idiom: 'pad';
+    readonly selected: true;
+}];
+export declare function appManifestStem(app: Pick<AppDefinition, 'id'>): string;
+export declare function appManifestPaths(app: Pick<AppDefinition, 'id'>, base: string): string[];
+export declare function appManifestFiles(app: AppDefinition, stem: string): {
+    [k: string]: string;
+};

package/dist/app/manifests.js

@@ -0,0 +1,20 @@
+import { generateSatinManifestJson } from './definition.js';
+// The dark URL remains an alias for installed clients. Each manifest carries
+// both appearances; selecting a manifest must never freeze the appearance.
+export const APP_MANIFEST_VARIANTS = [
+    { suffix: '.webmanifest', idiom: 'phone', selected: true },
+    { suffix: '-dark.webmanifest', idiom: 'phone', selected: false },
+    { suffix: '-ipad.webmanifest', idiom: 'pad', selected: true },
+];
+export function appManifestStem(app) {
+    return `satin-app-${encodeURIComponent(app.id).replaceAll('%', '_')}`;
+}
+export function appManifestPaths(app, base) {
+    return APP_MANIFEST_VARIANTS.map(variant => base + appManifestStem(app) + variant.suffix);
+}
+export function appManifestFiles(app, stem) {
+    return Object.fromEntries(APP_MANIFEST_VARIANTS.map(variant => [
+        stem + variant.suffix,
+        generateSatinManifestJson(app, variant.idiom),
+    ]));
+}

package/dist/app/mdm.d.ts

@@ -0,0 +1,3 @@
+import type { AppDefinition } from './definition.js';
+/** Apple's public WebClip payload. Status-bar appearance remains head-owned. */
+export declare function generateWebClipProfile(app: AppDefinition, icon: Uint8Array): string;

package/dist/app/mdm.js

@@ -0,0 +1,20 @@
+import { createHash } from 'node:crypto';
+/** Apple's public WebClip payload. Status-bar appearance remains head-owned. */
+export function generateWebClipProfile(app, icon) {
+    if (!app.mdm)
+        throw new Error('Set mdm.origin to export a WebClip profile.');
+    const escape = (value) => value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+    const identity = 'app.satin.' +
+        createHash('sha256')
+            .update(app.mdm.origin + app.id)
+            .digest('hex')
+            .slice(0, 24);
+    const uuid = (suffix) => {
+        const h = createHash('sha256')
+            .update(identity + suffix)
+            .digest('hex');
+        return `${h.slice(0, 8)}-${h.slice(8, 12)}-4${h.slice(13, 16)}-a${h.slice(17, 20)}-${h.slice(20, 32)}`;
+    };
+    const field = (key, value) => `<key>${key}</key><string>${escape(value)}</string>`;
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"><plist version="1.0"><dict>${field('PayloadType', 'Configuration')}${field('PayloadIdentifier', identity)}${field('PayloadUUID', uuid('profile'))}${field('PayloadDisplayName', app.name)}<key>PayloadVersion</key><integer>1</integer><key>PayloadContent</key><array><dict>${field('PayloadType', 'com.apple.webClip.managed')}${field('PayloadIdentifier', identity + '.clip')}${field('PayloadUUID', uuid('clip'))}<key>PayloadVersion</key><integer>1</integer>${field('Label', app.shortName)}${field('URL', new URL(app.startRoute, app.mdm.origin).href)}<key>FullScreen</key><true/><key>IsRemovable</key><true/><key>Precomposed</key><true/><key>IgnoreManifestScope</key><false/><key>Icon</key><data>${Buffer.from(icon).toString('base64')}</data></dict></array></dict></plist>\n`;
+}

package/dist/app/mediaCheck.d.ts

@@ -0,0 +1,9 @@
+import type { DeploymentFailure } from './deployment.js';
+/** CLI full-deployment check; not embedded into the lightweight install page. */
+export declare function checkMediaDeployment(inventory: Record<string, unknown>, entries: readonly {
+    url: string;
+    bytes?: number;
+}[], pageUrl: string, timeoutMs: number, base: string): Promise<{
+    applicable: boolean;
+    failures: DeploymentFailure[];
+}>;