toiljs 0.0.11 → 0.0.12

package/src/cli/ui.ts

@@ -1,103 +1,111 @@
-/**
- * Shared CLI presentation: the toiljs brand banner, gradient text, and small helpers.
- * Kept dependency-light (only picocolors); the gradient is hand-rolled truecolor ANSI so
- * the logo pops without pulling in a gradient library.
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import pc from 'picocolors';
-
-type RGB = readonly [number, number, number];
-
-/** toiljs brand palette. */
-const PRIMARY: RGB = [37, 99, 255];
-const SECONDARY: RGB = [124, 58, 237];
-const ACCENT: RGB = [34, 227, 171];
-
-/** Logo gradient stops: blue → purple → teal. */
-const GRADIENT: readonly RGB[] = [PRIMARY, SECONDARY, ACCENT];
-
-/** ANSI-shadow "TOIL" wordmark. */
-const ART: readonly string[] = [
-    '████████╗  ██████╗  ██╗ ██╗     ',
-    '╚══██╔══╝ ██╔═══██╗ ██║ ██║     ',
-    '   ██║    ██║   ██║ ██║ ██║     ',
-    '   ██║    ██║   ██║ ██║ ██║     ',
-    '   ██║    ╚██████╔╝ ██║ ███████╗',
-    '   ╚═╝     ╚═════╝  ╚═╝ ╚══════╝',
-];
-
-export const dim = pc.dim;
-export const bold = pc.bold;
-
-/** True when we should emit ANSI color: a TTY (or FORCE_COLOR), and not disabled via NO_COLOR. */
-function colorEnabled(): boolean {
-    if (process.env.NO_COLOR) return false;
-    if (process.env.FORCE_COLOR) return true;
-    return process.stdout.isTTY;
-}
-
-function rgb(color: RGB, s: string): string {
-    return colorEnabled() ? `\x1b[38;2;${color[0]};${color[1]};${color[2]}m${s}\x1b[39m` : s;
-}
-
-/** The primary brand accent (blue). No-ops to plain text when color is disabled. */
-export function brand(s: string): string {
-    return rgb(PRIMARY, s);
-}
-export const accent = brand;
-
-/** Success/positive accent (teal). */
-export function success(s: string): string {
-    return rgb(ACCENT, s);
-}
-
-/** Error accent (red, kept outside the brand palette since errors should read as errors). */
-export const danger = pc.red;
-
-function lerp(a: number, b: number, t: number): number {
-    return Math.round(a + (b - a) * t);
-}
-
-/** Samples the multi-stop brand gradient at `t` in [0, 1]. */
-function gradientAt(t: number): RGB {
-    const segments = GRADIENT.length - 1;
-    const scaled = t * segments;
-    const i = Math.min(Math.floor(scaled), segments - 1);
-    const a = GRADIENT[i];
-    const b = GRADIENT[i + 1];
-    const localT = scaled - i;
-    return [lerp(a[0], b[0], localT), lerp(a[1], b[1], localT), lerp(a[2], b[2], localT)];
-}
-
-/** Colors each character of `line` along the left→right brand gradient. */
-function gradientLine(line: string): string {
-    const n = line.length;
-    let out = '';
-    for (let i = 0; i < n; i++) {
-        const [r, g, b] = gradientAt(n > 1 ? i / (n - 1) : 0);
-        out += `\x1b[38;2;${r};${g};${b}m${line[i]}`;
-    }
-    return out + '\x1b[39m';
-}
-
-/** Reads the toiljs package version (CLI lives at build/cli/, package root is two up). */
-export function version(): string {
-    try {
-        const pkgPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'package.json');
-        const raw = fs.readFileSync(pkgPath, 'utf8');
-        const match = /"version"\s*:\s*"([^"]+)"/.exec(raw);
-        if (match && match[1]) return match[1];
-    } catch {}
-    return '0.0.0';
-}
-
-/** Prints the brand banner: gradient logo + tagline + version. */
-export function banner(): void {
-    const lines = colorEnabled() ? ART.map(gradientLine) : ART.slice();
-    const tagline = `  the most performant ${brand('react')} framework`;
-    const ver = `${dim('  v')}${brand(version())}`;
-    process.stdout.write('\n' + lines.join('\n') + '\n\n' + tagline + '   ' + ver + '\n\n');
-}
+/**
+ * Shared CLI presentation: the toiljs brand banner, gradient text, and small helpers.
+ * Kept dependency-light (only picocolors); the gradient is hand-rolled truecolor ANSI so
+ * the logo pops without pulling in a gradient library.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import pc from 'picocolors';
+
+type RGB = readonly [number, number, number];
+
+/** toiljs brand palette. */
+const PRIMARY: RGB = [37, 99, 255];
+const SECONDARY: RGB = [124, 58, 237];
+const ACCENT: RGB = [34, 227, 171];
+
+/** Logo gradient stops: blue → purple → teal. */
+const GRADIENT: readonly RGB[] = [PRIMARY, SECONDARY, ACCENT];
+
+/** ANSI-shadow "TOIL" wordmark. */
+const ART: readonly string[] = [
+    '████████╗  ██████╗  ██╗ ██╗     ',
+    '╚══██╔══╝ ██╔═══██╗ ██║ ██║     ',
+    '   ██║    ██║   ██║ ██║ ██║     ',
+    '   ██║    ██║   ██║ ██║ ██║     ',
+    '   ██║    ╚██████╔╝ ██║ ███████╗',
+    '   ╚═╝     ╚═════╝  ╚═╝ ╚══════╝',
+];
+
+export const dim = pc.dim;
+export const bold = pc.bold;
+
+/** True when we should emit ANSI color: a TTY (or FORCE_COLOR), and not disabled via NO_COLOR. */
+function colorEnabled(): boolean {
+    if (process.env.NO_COLOR) return false;
+    if (process.env.FORCE_COLOR) return true;
+    return process.stdout.isTTY;
+}
+
+function rgb(color: RGB, s: string): string {
+    return colorEnabled() ? `\x1b[38;2;${color[0]};${color[1]};${color[2]}m${s}\x1b[39m` : s;
+}
+
+/** The primary brand accent (blue). No-ops to plain text when color is disabled. */
+export function brand(s: string): string {
+    return rgb(PRIMARY, s);
+}
+export const accent = brand;
+
+/** Success/positive accent (teal). */
+export function success(s: string): string {
+    return rgb(ACCENT, s);
+}
+
+/** Error accent (red, kept outside the brand palette since errors should read as errors). */
+export const danger = pc.red;
+
+/** Warning accent (yellow, outside the brand palette so warnings read as warnings). */
+export const warn = pc.yellow;
+
+function lerp(a: number, b: number, t: number): number {
+    return Math.round(a + (b - a) * t);
+}
+
+/** Samples the multi-stop brand gradient at `t` in [0, 1]. */
+function gradientAt(t: number): RGB {
+    const segments = GRADIENT.length - 1;
+    const scaled = t * segments;
+    const i = Math.min(Math.floor(scaled), segments - 1);
+    const a = GRADIENT[i];
+    const b = GRADIENT[i + 1];
+    const localT = scaled - i;
+    return [lerp(a[0], b[0], localT), lerp(a[1], b[1], localT), lerp(a[2], b[2], localT)];
+}
+
+/** Colors each character of `line` along the left→right brand gradient. */
+function gradientLine(line: string): string {
+    const n = line.length;
+    let out = '';
+    for (let i = 0; i < n; i++) {
+        const [r, g, b] = gradientAt(n > 1 ? i / (n - 1) : 0);
+        out += `\x1b[38;2;${r};${g};${b}m${line[i]}`;
+    }
+    return out + '\x1b[39m';
+}
+
+/** Reads the toiljs package version (CLI lives at build/cli/, package root is two up). */
+export function version(): string {
+    try {
+        const pkgPath = path.resolve(
+            path.dirname(fileURLToPath(import.meta.url)),
+            '..',
+            '..',
+            'package.json',
+        );
+        const raw = fs.readFileSync(pkgPath, 'utf8');
+        const match = /"version"\s*:\s*"([^"]+)"/.exec(raw);
+        if (match && match[1]) return match[1];
+    } catch {}
+    return '0.0.0';
+}
+
+/** Prints the brand banner: gradient logo + tagline + version. */
+export function banner(): void {
+    const lines = colorEnabled() ? ART.map(gradientLine) : ART.slice();
+    const tagline = `  the most performant ${brand('react')} framework`;
+    const ver = `${dim('  v')}${brand(version())}`;
+    process.stdout.write('\n' + lines.join('\n') + '\n\n' + tagline + '   ' + ver + '\n\n');
+}

package/src/cli/update.ts

@@ -0,0 +1,150 @@
+/**
+ * `toiljs update`, a friendly wrapper over `npm-check-updates`: checks the registry for newer
+ * dependency versions, shows them grouped by semver bump (major / minor / patch) with colors, lets
+ * you pick which to apply (or `-y` for all), bumps package.json, and runs the project's package
+ * manager install. ncu is invoked via `npx --yes` so it isn't a permanent dependency of toiljs.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { cancel, intro, isCancel, multiselect, note, outro, spinner } from '@clack/prompts';
+
+import { capture, run } from './proc.js';
+import { buildRows, type Bump, parseNcuJson, type UpdateRow } from './updates.js';
+import { accent, danger, dim, success, warn } from './ui.js';
+
+export interface UpdateOptions {
+    readonly root?: string;
+    readonly cwd: string;
+    /** Apply all available updates without the interactive picker. */
+    readonly yes?: boolean;
+    /** ncu `--target` (latest | minor | patch | newest | greatest). Default latest. */
+    readonly target?: string;
+}
+
+interface PackageManager {
+    readonly name: string;
+    readonly ncuName: string;
+}
+
+/** Detects the package manager from the project's lockfile (defaults to npm). */
+function detectPackageManager(root: string): PackageManager {
+    if (fs.existsSync(path.join(root, 'pnpm-lock.yaml'))) return { name: 'pnpm', ncuName: 'pnpm' };
+    if (fs.existsSync(path.join(root, 'yarn.lock'))) return { name: 'yarn', ncuName: 'yarn' };
+    if (fs.existsSync(path.join(root, 'bun.lockb'))) return { name: 'bun', ncuName: 'bun' };
+    return { name: 'npm', ncuName: 'npm' };
+}
+
+/** Reads the merged dependency ranges (deps + devDeps) from a package.json. */
+function readDependencies(pkgPath: string): Record<string, string> {
+    const parsed: unknown = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    if (typeof parsed !== 'object' || parsed === null) return {};
+    const pkg = parsed as Record<string, unknown>;
+    const merge = (v: unknown): Record<string, string> => {
+        if (typeof v !== 'object' || v === null) return {};
+        const out: Record<string, string> = {};
+        for (const [k, val] of Object.entries(v)) if (typeof val === 'string') out[k] = val;
+        return out;
+    };
+    return { ...merge(pkg.dependencies), ...merge(pkg.devDependencies) };
+}
+
+function bumpColor(bump: Bump, text: string): string {
+    if (bump === 'major') return danger(text);
+    if (bump === 'minor') return warn(text);
+    if (bump === 'patch') return success(text);
+    return dim(text);
+}
+
+/** Renders a row as `name  from -> to`, the version part colored by bump. */
+function rowLine(row: UpdateRow): string {
+    return `${row.name}  ${dim(row.from)} ${dim('->')} ${bumpColor(row.bump, row.to)}`;
+}
+
+const TARGETS = new Set(['latest', 'minor', 'patch', 'newest', 'greatest']);
+
+export async function runUpdate(opts: UpdateOptions): Promise<void> {
+    const root = path.resolve(opts.root ?? opts.cwd);
+    const pkgPath = path.join(root, 'package.json');
+    if (!fs.existsSync(pkgPath)) {
+        throw new Error('No package.json here. Run from your project root or pass --root <dir>.');
+    }
+    const currentDeps = readDependencies(pkgPath);
+    const pm = detectPackageManager(root);
+    const target = opts.target && TARGETS.has(opts.target) ? opts.target : 'latest';
+
+    const ncuArgs = (extra: string[]): string[] => [
+        '--yes',
+        'npm-check-updates',
+        '--packageManager',
+        pm.ncuName,
+        '--target',
+        target,
+        ...extra,
+    ];
+
+    intro(accent('toiljs update'));
+
+    const s = spinner();
+    s.start('Checking the registry for updates');
+    const res = await capture('npx', ncuArgs(['--jsonUpgraded']), root);
+    if (res.code !== 0 && res.stdout.indexOf('{') === -1) {
+        s.stop('Could not check for updates');
+        note(dim(res.stderr.trim() || 'npm-check-updates failed.'), 'Error');
+        process.exitCode = 1;
+        return;
+    }
+    const rows = buildRows(parseNcuJson(res.stdout), currentDeps);
+    if (rows.length === 0) {
+        s.stop('Everything is up to date');
+        outro(success('Nothing to update.'));
+        return;
+    }
+    s.stop(`${String(rows.length)} update${rows.length === 1 ? '' : 's'} available`);
+
+    const counts = { major: 0, minor: 0, patch: 0, other: 0 };
+    for (const r of rows) counts[r.bump]++;
+    note(
+        rows.map(rowLine).join('\n'),
+        `${danger(`${String(counts.major)} major`)}  ${warn(`${String(counts.minor)} minor`)}  ${success(`${String(counts.patch)} patch`)}`,
+    );
+
+    let selected: string[];
+    if (opts.yes) {
+        selected = rows.map((r) => r.name);
+    } else {
+        const answer = await multiselect<string>({
+            message: 'Select packages to update (space to toggle, enter to confirm)',
+            options: rows.map((r) => ({
+                value: r.name,
+                label: r.name,
+                hint: `${r.from} -> ${r.to}`,
+            })),
+            initialValues: rows.map((r) => r.name),
+            required: false,
+        });
+        if (isCancel(answer)) {
+            cancel('Update cancelled.');
+            return;
+        }
+        selected = answer;
+    }
+
+    if (selected.length === 0) {
+        outro(dim('No packages selected.'));
+        return;
+    }
+
+    s.start('Updating package.json');
+    const applyAll = selected.length === rows.length;
+    await run('npx', ncuArgs(applyAll ? ['-u'] : ['-u', '--filter', selected.join(' ')]), root);
+    s.stop('package.json updated');
+
+    s.start(`Installing with ${pm.name}`);
+    await run(pm.name, ['install'], root);
+    s.stop('Dependencies installed');
+
+    outro(
+        success(`Updated ${String(selected.length)} package${selected.length === 1 ? '' : 's'}.`),
+    );
+}

package/src/cli/updates.ts

@@ -0,0 +1,69 @@
+/**
+ * Pure helpers for `toiljs update`: parse `npm-check-updates --jsonUpgraded` output and classify the
+ * semver bump of each upgrade. IO-free so it can be unit-tested; the spawn/UI live in `update.ts`.
+ */
+
+/** The kind of version jump an upgrade represents. */
+export type Bump = 'major' | 'minor' | 'patch' | 'other';
+
+/** One available upgrade: package, current range, target range, and bump kind. */
+export interface UpdateRow {
+    readonly name: string;
+    readonly from: string;
+    readonly to: string;
+    readonly bump: Bump;
+}
+
+/** Extracts a version's leading `x.y.z` (ignoring `^`, `~`, `>=`, etc.); missing parts become 0. */
+function parseVersion(v: string): [number, number, number] {
+    const m = /(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(v);
+    if (!m) return [0, 0, 0];
+    return [Number(m[1]), Number(m[2] ?? 0), Number(m[3] ?? 0)];
+}
+
+/** Classifies the bump from `from` to `to` (both may be ranges like `^1.2.3`). */
+export function classifyBump(from: string, to: string): Bump {
+    const [fa, fb, fc] = parseVersion(from);
+    const [ta, tb, tc] = parseVersion(to);
+    if (ta !== fa) return 'major';
+    if (tb !== fb) return 'minor';
+    if (tc !== fc) return 'patch';
+    return 'other';
+}
+
+/**
+ * Parses the JSON object `npm-check-updates --jsonUpgraded` prints (a `{ name: range }` map). Tolerant
+ * of leading/trailing noise (npx banners) by slicing to the outermost braces. Returns `{}` on failure.
+ */
+export function parseNcuJson(stdout: string): Record<string, string> {
+    const start = stdout.indexOf('{');
+    const end = stdout.lastIndexOf('}');
+    if (start === -1 || end <= start) return {};
+    try {
+        const parsed: unknown = JSON.parse(stdout.slice(start, end + 1));
+        if (typeof parsed !== 'object' || parsed === null) return {};
+        const out: Record<string, string> = {};
+        for (const [k, v] of Object.entries(parsed)) if (typeof v === 'string') out[k] = v;
+        return out;
+    } catch {
+        return {};
+    }
+}
+
+const SEVERITY: Record<Bump, number> = { major: 0, minor: 1, patch: 2, other: 3 };
+
+/**
+ * Builds the upgrade rows from the ncu map and the project's current dependency ranges, sorted by
+ * bump severity (major first) then name.
+ */
+export function buildRows(
+    upgraded: Record<string, string>,
+    currentDeps: Record<string, string>,
+): UpdateRow[] {
+    return Object.entries(upgraded)
+        .map(([name, to]) => {
+            const from = currentDeps[name] ?? '?';
+            return { name, from, to, bump: classifyBump(from, to) };
+        })
+        .sort((a, b) => SEVERITY[a.bump] - SEVERITY[b.bump] || a.name.localeCompare(b.name));
+}

package/src/client/components/Image.tsx

@@ -1,89 +1,91 @@
-import { useState, type CSSProperties, type ComponentPropsWithRef, type ReactNode } from 'react';
-
-/**
- * Props for {@link Image}: every standard `<img>` attribute, plus toil's layout/loading controls.
- * `src` and `alt` are required (`alt` is enforced for accessibility, pass `alt=""` for decorative
- * images). `width`/`height` (or `fill`) reserve space to prevent layout shift.
- */
-export interface ImageProps
-    extends Omit<ComponentPropsWithRef<'img'>, 'loading' | 'placeholder' | 'width' | 'height'> {
-    src: string;
-    alt: string;
-    /** Intrinsic width in px. Set together with `height` to reserve space (avoids layout shift). */
-    width?: number;
-    /** Intrinsic height in px. Set together with `width` to reserve space (avoids layout shift). */
-    height?: number;
-    /**
-     * Fill the nearest positioned ancestor (the parent must be `position: relative|absolute|fixed`).
-     * The image is absolutely positioned at 100% × 100%; `width`/`height` are ignored. Pair with
-     * `objectFit` to control cropping.
-     */
-    fill?: boolean;
-    /** `object-fit` for the rendered image (handy with `fill`). */
-    objectFit?: CSSProperties['objectFit'];
-    /**
-     * Mark this as a high-priority (LCP) image: eager load + `fetchpriority="high"` and no lazy
-     * loading. Use for above-the-fold hero images; everything else stays lazy. Default `false`.
-     */
-    priority?: boolean;
-    /** Placeholder shown until the image loads: `'empty'` (default) or `'blur'` (needs `blurDataURL`). */
-    placeholder?: 'empty' | 'blur';
-    /** A tiny (base64) image shown blurred behind the image while it loads, when `placeholder="blur"`. */
-    blurDataURL?: string;
-}
-
-/**
- * A drop-in `<img>` replacement that prevents layout shift and lazy-loads by default. It reserves
- * space from `width`/`height` (or fills its container with `fill`), decodes async, lazy-loads unless
- * `priority`, and can fade in from a `blur` placeholder. This is a client-only component, there is
- * no server-side resizing; pass an already-optimized `src` (Vite hashes imported assets for you).
- */
-export function Image(props: ImageProps): ReactNode {
-    const {
-        src,
-        alt,
-        width,
-        height,
-        fill = false,
-        objectFit,
-        priority = false,
-        placeholder = 'empty',
-        blurDataURL,
-        style,
-        onLoad,
-        ...rest
-    } = props;
-
-    const [loaded, setLoaded] = useState(false);
-    const showBlur = placeholder === 'blur' && blurDataURL !== undefined && !loaded;
-
-    const layoutStyle: CSSProperties = fill
-        ? { position: 'absolute', inset: 0, width: '100%', height: '100%' }
-        : {};
-    const blurStyle: CSSProperties = showBlur
-        ? {
-              backgroundImage: `url(${blurDataURL})`,
-              backgroundSize: 'cover',
-              backgroundPosition: 'center',
-              filter: 'blur(20px)',
-          }
-        : {};
-
-    return (
-        <img
-            {...rest}
-            src={src}
-            alt={alt}
-            width={fill ? undefined : width}
-            height={fill ? undefined : height}
-            loading={priority ? 'eager' : 'lazy'}
-            decoding="async"
-            fetchPriority={priority ? 'high' : 'auto'}
-            onLoad={(event) => {
-                setLoaded(true);
-                onLoad?.(event);
-            }}
-            style={{ ...layoutStyle, objectFit, ...blurStyle, ...style }}
-        />
-    );
-}
+import { useState, type CSSProperties, type ComponentPropsWithRef, type ReactNode } from 'react';
+
+/**
+ * Props for {@link Image}: every standard `<img>` attribute, plus toil's layout/loading controls.
+ * `src` and `alt` are required (`alt` is enforced for accessibility, pass `alt=""` for decorative
+ * images). `width`/`height` (or `fill`) reserve space to prevent layout shift.
+ */
+export interface ImageProps extends Omit<
+    ComponentPropsWithRef<'img'>,
+    'loading' | 'placeholder' | 'width' | 'height'
+> {
+    src: string;
+    alt: string;
+    /** Intrinsic width in px. Set together with `height` to reserve space (avoids layout shift). */
+    width?: number;
+    /** Intrinsic height in px. Set together with `width` to reserve space (avoids layout shift). */
+    height?: number;
+    /**
+     * Fill the nearest positioned ancestor (the parent must be `position: relative|absolute|fixed`).
+     * The image is absolutely positioned at 100% × 100%; `width`/`height` are ignored. Pair with
+     * `objectFit` to control cropping.
+     */
+    fill?: boolean;
+    /** `object-fit` for the rendered image (handy with `fill`). */
+    objectFit?: CSSProperties['objectFit'];
+    /**
+     * Mark this as a high-priority (LCP) image: eager load + `fetchpriority="high"` and no lazy
+     * loading. Use for above-the-fold hero images; everything else stays lazy. Default `false`.
+     */
+    priority?: boolean;
+    /** Placeholder shown until the image loads: `'empty'` (default) or `'blur'` (needs `blurDataURL`). */
+    placeholder?: 'empty' | 'blur';
+    /** A tiny (base64) image shown blurred behind the image while it loads, when `placeholder="blur"`. */
+    blurDataURL?: string;
+}
+
+/**
+ * A drop-in `<img>` replacement that prevents layout shift and lazy-loads by default. It reserves
+ * space from `width`/`height` (or fills its container with `fill`), decodes async, lazy-loads unless
+ * `priority`, and can fade in from a `blur` placeholder. This is a client-only component, there is
+ * no server-side resizing; pass an already-optimized `src` (Vite hashes imported assets for you).
+ */
+export function Image(props: ImageProps): ReactNode {
+    const {
+        src,
+        alt,
+        width,
+        height,
+        fill = false,
+        objectFit,
+        priority = false,
+        placeholder = 'empty',
+        blurDataURL,
+        style,
+        onLoad,
+        ...rest
+    } = props;
+
+    const [loaded, setLoaded] = useState(false);
+    const showBlur = placeholder === 'blur' && blurDataURL !== undefined && !loaded;
+
+    const layoutStyle: CSSProperties = fill
+        ? { position: 'absolute', inset: 0, width: '100%', height: '100%' }
+        : {};
+    const blurStyle: CSSProperties = showBlur
+        ? {
+              backgroundImage: `url(${blurDataURL})`,
+              backgroundSize: 'cover',
+              backgroundPosition: 'center',
+              filter: 'blur(20px)',
+          }
+        : {};
+
+    return (
+        <img
+            {...rest}
+            src={src}
+            alt={alt}
+            width={fill ? undefined : width}
+            height={fill ? undefined : height}
+            loading={priority ? 'eager' : 'lazy'}
+            decoding="async"
+            fetchPriority={priority ? 'high' : 'auto'}
+            onLoad={(event) => {
+                setLoaded(true);
+                onLoad?.(event);
+            }}
+            style={{ ...layoutStyle, objectFit, ...blurStyle, ...style }}
+        />
+    );
+}