@vizzly-testing/cli 0.39.0 → 0.39.2

package/dist/domains/updates/cli-update.js

@@ -0,0 +1,103 @@
+import { execFile, spawn } from 'node:child_process';
+import { access, readFile, realpath } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { getPackageName, getPackageRoot } from '../../shared/package-info.js';
+let exec = promisify(execFile);
+let installCommands = {
+  npm: 'install',
+  pnpm: 'add'
+};
+let saveFlags = {
+  dependencies: '--save-prod',
+  devDependencies: '--save-dev',
+  optionalDependencies: '--save-optional'
+};
+async function exists(filename) {
+  try {
+    await access(filename);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Only offer an installer when the running package can be matched to that
+// installation. A checkout, npx cache, or unknown manager gets manual guidance.
+export async function findCliUpdatePlan(cwd, version, packageRoot = getPackageRoot()) {
+  if (!/^\d+\.\d+\.\d+$/.test(version)) return null;
+  let installed = await realpath(packageRoot);
+  if (!installed.split(path.sep).includes('node_modules')) return null;
+  let name = getPackageName();
+  let spec = `${name}@${version}`;
+  for (let directory = cwd;; directory = path.dirname(directory)) {
+    let manifest = path.join(directory, 'package.json');
+    try {
+      let pkg = JSON.parse(await readFile(manifest, 'utf8'));
+      let group = Object.keys(saveFlags).find(key => pkg[key]?.[name]);
+      if (group) {
+        let resolved = createRequire(manifest).resolve(name);
+        if ((await realpath(resolved)) !== path.join(installed, 'dist', 'index.js')) return null;
+        if (/^(workspace:|file:|link:|git|https?:|npm:)/.test(pkg[group][name])) return null;
+        let manager = pkg.packageManager?.split('@')[0];
+        if (!manager) {
+          if (await exists(path.join(directory, 'pnpm-lock.yaml'))) manager = 'pnpm';else if (await exists(path.join(directory, 'package-lock.json'))) manager = 'npm';
+        }
+        if (!['npm', 'pnpm'].includes(manager)) return null;
+        let args = [installCommands[manager], saveFlags[group]];
+        let preserveExactVersion = /^\d+\.\d+\.\d+(?:[-+].*)?$/.test(pkg[group][name]);
+        if (preserveExactVersion) args.push('--save-exact');
+        args.push(spec);
+        return {
+          command: manager,
+          args,
+          cwd: directory,
+          cliPath: path.join(directory, 'node_modules', name, 'bin', 'vizzly.js')
+        };
+      }
+    } catch {
+      // Keep looking for the workspace manifest that owns the dependency.
+    }
+    if (directory === path.dirname(directory)) break;
+  }
+  for (let manager of ['npm', 'pnpm']) {
+    try {
+      let {
+        stdout
+      } = await exec(manager, ['root', '--global'], {
+        timeout: 3000
+      });
+      let globalPackage = path.join(stdout.trim(), name);
+      if ((await realpath(globalPackage)) === installed) {
+        return {
+          command: manager,
+          args: [installCommands[manager], '--global', spec],
+          cwd,
+          cliPath: path.join(globalPackage, 'bin', 'vizzly.js')
+        };
+      }
+    } catch {
+      // An unavailable manager cannot own an update we offer to install.
+    }
+  }
+  return null;
+}
+function runProcess(command, args, cwd, stdio) {
+  return new Promise((resolve, reject) => {
+    let child = spawn(command, args, {
+      cwd,
+      stdio,
+      shell: process.platform === 'win32' && ['npm', 'pnpm'].includes(command)
+    });
+    child.once('error', reject);
+    child.once('close', (code, signal) => resolve(code ?? (signal === 'SIGINT' ? 130 : 1)));
+  });
+}
+export async function runUpdateProcess(command, args, cwd) {
+  let code = await runProcess(command, args, cwd, ['inherit', process.stderr, process.stderr]);
+  if (code !== 0) throw new Error(`${command} exited with status ${code}.`);
+}
+export function runUpdatedCli(cliPath, args, cwd) {
+  return runProcess(process.execPath, [cliPath, '--no-update-notifier', ...args], cwd, 'inherit');
+}

package/dist/domains/updates/update-check.js

@@ -0,0 +1,2 @@
+import { checkForUpdate } from './update-notifications.js';
+await checkForUpdate();

package/dist/domains/updates/update-notifications.js

@@ -0,0 +1,175 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { applyChanges, fileChange, preflightChanges } from '../../shared/file-changes.js';
+import { readOptionalFile } from '../../shared/files.js';
+import { getGlobalConfigDir } from '../../shared/global-config.js';
+import * as output from '../../shared/output.js';
+import { getPackageName, getPackageVersion } from '../../shared/package-info.js';
+import { agentGuidanceFlag, agentGuidancePath, bundledAgentSkill, planAgentSetup } from '../setup/agent-setup.js';
+import { createPrompts } from '../setup/setup-prompts.js';
+import { findCliUpdatePlan, runUpdateProcess } from './cli-update.js';
+let day = 24 * 60 * 60 * 1000;
+async function readState(filename) {
+  try {
+    let state = JSON.parse(await readOptionalFile(filename));
+    return state && typeof state === 'object' && !Array.isArray(state) ? state : {};
+  } catch {
+    return {};
+  }
+}
+async function stateChange(filename, state) {
+  return fileChange(filename, `${JSON.stringify(state, null, 2)}\n`);
+}
+
+// The registry's latest tag contains stable releases. Never suggest a downgrade
+// or a prerelease, even when an unexpected registry response is cached.
+export function isNewerStableVersion(candidate, current) {
+  let latest = /^(\d+)\.(\d+)\.(\d+)$/.exec(candidate);
+  let installed = /^(\d+)\.(\d+)\.(\d+)(-[\w.-]+)?(?:\+[\w.-]+)?$/.exec(current);
+  if (!latest || !installed) return false;
+  for (let index = 1; index <= 3; index++) {
+    let difference = Number(latest[index]) - Number(installed[index]);
+    if (difference) return difference > 0;
+  }
+  return Boolean(installed[4]);
+}
+export async function checkForUpdate() {
+  try {
+    let filename = path.join(getGlobalConfigDir(), 'updates.json');
+    let response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(getPackageName())}/latest`, {
+      signal: AbortSignal.timeout(3000)
+    });
+    if (!response.ok) return;
+    let {
+      version
+    } = await response.json();
+    if (!/^\d+\.\d+\.\d+$/.test(version)) return;
+    // Keep notice history saved while the network request was in flight.
+    let state = await readState(filename);
+    await applyChanges([await stateChange(filename, {
+      ...state,
+      latestVersion: version
+    })]);
+  } catch {
+    // Update checks never affect the command being run.
+  }
+}
+async function offerUpdate(cwd, {
+  cliVersion,
+  guidanceFlag
+}) {
+  if (!process.stdin.isTTY) return;
+  let cliPlan = cliVersion ? await findCliUpdatePlan(cwd, cliVersion) : null;
+  if (!cliPlan && !guidanceFlag) return;
+  let updatedCli;
+  try {
+    let guidancePlan;
+    if (!cliPlan && guidanceFlag) {
+      guidancePlan = await planAgentSetup(cwd, {
+        skill: true,
+        guidance: guidanceFlag === '--agent-guidance'
+      });
+      await preflightChanges(guidancePlan.changes);
+    }
+    if (cliPlan) {
+      output.printErr(`  Apply: ${cliPlan.command} ${cliPlan.args.join(' ')} (in ${cliPlan.cwd})`);
+      // A CLI upgrade can bring new guidance even if the current bundle matches.
+      if (!guidanceFlag && (await readOptionalFile(path.join(cwd, '.agents', 'skills', 'vizzly', 'SKILL.md')))) {
+        guidanceFlag = await agentGuidanceFlag(cwd);
+      }
+    }
+    if (guidanceFlag) {
+      output.printErr(`  Refresh: vizzly init ${guidanceFlag} (replaces bundled skill files${guidanceFlag === '--agent-guidance' ? ' and the Vizzly AGENTS.md note' : ''})`);
+    }
+    if (!(await confirmUpdate())) return;
+    if (cliPlan) {
+      await runUpdateProcess(cliPlan.command, cliPlan.args, cliPlan.cwd);
+      updatedCli = cliPlan.cliPath;
+      if (guidanceFlag) {
+        await runUpdateProcess(process.execPath, [cliPlan.cliPath, 'init', guidanceFlag, '--no-update-notifier'], cwd);
+      }
+    } else {
+      await applyChanges(guidancePlan.changes);
+    }
+    output.printErr('  Vizzly update applied.');
+  } catch (error) {
+    if (error.code !== 'INIT_CANCELLED') output.printErr(`  Could not apply the Vizzly update: ${error.message}`);
+  }
+  return updatedCli;
+}
+async function confirmUpdate() {
+  let prompts = createPrompts();
+  try {
+    return await prompts.confirm('Apply available Vizzly updates now?');
+  } finally {
+    prompts.close();
+  }
+}
+async function planGuidanceNotice(cwd, cliVersion) {
+  let installed = await readOptionalFile(path.join(cwd, '.agents', 'skills', 'vizzly', 'SKILL.md'));
+  let guidance = await readState(agentGuidancePath(cwd));
+  if (!installed || isNewerStableVersion(guidance.cliVersion, cliVersion)) return null;
+  let {
+    version,
+    files
+  } = await bundledAgentSkill();
+  if (!guidance.version) {
+    let contents = await Promise.all(files.map(({
+      filename
+    }) => readOptionalFile(path.join(cwd, '.agents', 'skills', 'vizzly', filename))));
+    if (files.every(({
+      content
+    }, index) => content === contents[index])) guidance.version = version;
+  }
+  if (guidance.version === version || guidance.notifiedVersion === version) return null;
+  let flag = await agentGuidanceFlag(cwd);
+  return {
+    flag,
+    message: `Vizzly agent guidance has an update. Run vizzly init ${flag} to refresh it.`,
+    change: await stateChange(agentGuidancePath(cwd), {
+      ...guidance,
+      notifiedVersion: version
+    })
+  };
+}
+function startUpdateCheck() {
+  output.printErr('  Checking for Vizzly updates in the background…');
+  let child = spawn(process.execPath, [fileURLToPath(new URL('./update-check.js', import.meta.url))], {
+    detached: true,
+    stdio: 'ignore'
+  });
+  child.on('error', () => {});
+  child.unref();
+}
+export async function notifyUpdates(options = {}) {
+  if (options.updateNotifier === false || options.json || output.isJson() || !process.stderr.isTTY || !process.stdout.isTTY || process.env.CI || 'NO_UPDATE_NOTIFIER' in process.env || 'VIZZLY_NO_UPDATE_NOTIFIER' in process.env || !['info', 'debug'].includes(output.getLogLevel())) return;
+  try {
+    let cwd = process.cwd();
+    let filename = path.join(getGlobalConfigDir(), 'updates.json');
+    let state = await readState(filename);
+    let messages = [];
+    let available = {};
+    let cliVersion = getPackageVersion();
+    if (isNewerStableVersion(state.latestVersion, cliVersion) && state.notifiedCliVersion !== state.latestVersion) {
+      messages.push(`Vizzly ${state.latestVersion} is available (installed: ${cliVersion}). Update ${getPackageName()} with the package manager that installed it.`);
+      state.notifiedCliVersion = state.latestVersion;
+      available.cliVersion = state.latestVersion;
+    }
+    let guidanceNotice = await planGuidanceNotice(cwd, cliVersion);
+    if (guidanceNotice) {
+      messages.push(guidanceNotice.message);
+      available.guidanceFlag = guidanceNotice.flag;
+    }
+    let checkDue = !Number.isFinite(state.lastCheckedAt) || state.lastCheckedAt > Date.now() || Date.now() - state.lastCheckedAt >= day;
+    if (checkDue) state.lastCheckedAt = Date.now();
+    // If state cannot be saved, stay quiet instead of repeating a notice on
+    // every invocation. Setup's file preflight also protects against symlinks.
+    await applyChanges([guidanceNotice?.change, await stateChange(filename, state)]);
+    for (let message of messages) output.printErr(`  ${message}`);
+    if (checkDue) startUpdateCheck();
+    return await offerUpdate(cwd, available);
+  } catch {
+    // Missing, malformed, or unwritable metadata must not break CLI commands.
+  }
+}

package/dist/domains/uploads/upload-defaults.js

@@ -0,0 +1,4 @@
+export let DEFAULT_BATCH_SIZE = 50;
+export let DEFAULT_SHA_CHECK_BATCH_SIZE = 100;
+export let DEFAULT_TIMEOUT = 30000;
+export let DEFAULT_BUILD_POLL_INTERVAL = 1000;

package/dist/domains/uploads/upload-files.js

@@ -0,0 +1,32 @@
+import crypto from 'node:crypto';
+
+/**
+ * Compute SHA256 hash of a buffer
+ * @param {Buffer} buffer - File buffer
+ * @returns {string} Hex-encoded SHA256 hash
+ */
+export function computeSha256(buffer) {
+  return crypto.createHash('sha256').update(buffer).digest('hex');
+}
+
+/**
+ * Partition files into those that need upload and those that exist
+ * @param {Array} fileMetadata - All file metadata
+ * @param {Set} existingShas - Set of SHAs that already exist
+ * @returns {{ toUpload: Array, existing: Array }}
+ */
+export function partitionFilesByExistence(fileMetadata, existingShas) {
+  return {
+    toUpload: fileMetadata.filter(f => !existingShas.has(f.sha256)),
+    existing: fileMetadata.filter(f => existingShas.has(f.sha256))
+  };
+}
+
+/**
+ * Build glob pattern for screenshots
+ * @param {string} directory - Base directory
+ * @returns {string} Glob pattern
+ */
+export function buildScreenshotPattern(directory) {
+  return `${directory}/**/*.png`;
+}

package/dist/domains/uploads/upload-settings.js

@@ -0,0 +1,21 @@
+import { DEFAULT_BATCH_SIZE, DEFAULT_TIMEOUT } from './upload-defaults.js';
+
+/**
+ * Resolve batch size from options and config
+ * @param {Object} options - Runtime options
+ * @param {Object} uploadConfig - Upload configuration
+ * @returns {number} Resolved batch size
+ */
+export function resolveBatchSize(options, uploadConfig) {
+  return Number(options?.batchSize ?? uploadConfig?.batchSize ?? DEFAULT_BATCH_SIZE);
+}
+
+/**
+ * Resolve timeout from options and config
+ * @param {Object} options - Runtime options
+ * @param {Object} uploadConfig - Upload configuration
+ * @returns {number} Resolved timeout in ms
+ */
+export function resolveTimeout(options, uploadConfig) {
+  return Number(options?.timeout ?? uploadConfig?.timeout ?? DEFAULT_TIMEOUT);
+}

package/dist/domains/uploads/upload-timing.js

@@ -0,0 +1,18 @@
+/**
+ * Check if timeout has been exceeded
+ * @param {number} startTime - Start timestamp
+ * @param {number} timeout - Timeout in ms
+ * @returns {boolean} True if timed out
+ */
+export function isTimedOut(startTime, timeout, now = Date.now()) {
+  return now - startTime >= timeout;
+}
+
+/**
+ * Get elapsed time since start
+ * @param {number} startTime - Start timestamp
+ * @returns {number} Elapsed time in ms
+ */
+export function getElapsedTime(startTime, now = Date.now()) {
+  return now - startTime;
+}

package/dist/{commands/upload.js → domains/uploads/upload.commands.js}

@@ -1,11 +1,13 @@
-import { createApiClient as defaultCreateApiClient, finalizeBuild as defaultFinalizeBuild, getTokenContext as defaultGetTokenContext } from '../api/index.js';
-import { CONFIG_DEFAULTS } from '../config/core.js';
-import { createUploader as defaultCreateUploader } from '../uploader/index.js';
-import { getAppBaseUrl } from '../utils/api-url.js';
-import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
-import { detectBranch as defaultDetectBranch, detectCommit as defaultDetectCommit, detectCommitAuthor as defaultDetectCommitAuthor, detectCommitMessage as defaultDetectCommitMessage, detectPullRequestNumber as defaultDetectPullRequestNumber, generateBuildNameWithGit as defaultGenerateBuildNameWithGit } from '../utils/git.js';
-import * as defaultOutput from '../utils/output.js';
-import { writeSession as defaultWriteSession } from '../utils/session.js';
+import { getAppBaseUrl } from '../../shared/api-url.js';
+import { detectBranch as defaultDetectBranch, detectCommit as defaultDetectCommit, detectCommitAuthor as defaultDetectCommitAuthor, detectCommitMessage as defaultDetectCommitMessage, detectPullRequestNumber as defaultDetectPullRequestNumber, generateBuildNameWithGit as defaultGenerateBuildNameWithGit } from '../../shared/git.js';
+import * as defaultOutput from '../../shared/output.js';
+import { createApiClient as defaultCreateApiClient } from '../auth/cloud-client.js';
+import { finalizeBuild as defaultFinalizeBuild } from '../builds/build.service.js';
+import { CONFIG_DEFAULTS } from '../config/config-defaults.js';
+import { loadConfig as defaultLoadConfig } from '../config/config-loader.js';
+import { getTokenContext as defaultGetTokenContext } from '../context/context.service.js';
+import { writeSession as defaultWriteSession } from '../runs/session-store.js';
+import { createUploader as defaultCreateUploader } from './upload.service.js';
 
 /**
  * Construct proper build URL with org/project context
@@ -380,7 +382,7 @@ export async function uploadCommand(screenshotsPath, options = {}, globalOptions
  * @param {Object} options - Command options
  */
 export function validateUploadOptions(screenshotsPath, options) {
-  const errors = [];
+  let errors = [];
   if (!screenshotsPath) {
     errors.push('Screenshots path is required');
   }

package/dist/domains/uploads/upload.normalizers.js

@@ -0,0 +1,60 @@
+import { basename } from 'node:path';
+import { computeSha256 } from './upload-files.js';
+let KNOWN_BROWSERS = ['chrome', 'firefox', 'safari', 'edge', 'webkit'];
+
+/**
+ * Extract browser name from filename
+ * @param {string} filename - The screenshot filename
+ * @returns {string|null} Browser name or null if not found
+ */
+export function extractBrowserFromFilename(filename) {
+  let lowerFilename = filename.toLowerCase();
+  for (let browser of KNOWN_BROWSERS) {
+    if (lowerFilename.includes(browser)) {
+      return browser;
+    }
+  }
+  return null;
+}
+
+/**
+ * Build file metadata object
+ * @param {string} filePath - Path to file
+ * @param {Buffer} buffer - File contents
+ * @returns {Object} File metadata
+ */
+export function buildFileMetadata(filePath, buffer) {
+  return {
+    path: filePath,
+    filename: basename(filePath),
+    buffer,
+    sha256: computeSha256(buffer)
+  };
+}
+
+/**
+ * Convert file metadata to screenshot check format
+ * @param {Object} file - File metadata
+ * @returns {Object} Screenshot format for SHA check
+ */
+export function fileToScreenshotFormat(file) {
+  let browser = extractBrowserFromFilename(file.filename);
+  return {
+    sha256: file.sha256,
+    name: file.filename.replace(/\.png$/, ''),
+    filename: file.filename,
+    properties: browser ? {
+      browser
+    } : {}
+  };
+}
+
+/**
+ * Extract status code from error message
+ * @param {string} errorMessage - Error message
+ * @returns {string} Status code or 'unknown'
+ */
+export function extractStatusCodeFromError(errorMessage) {
+  let match = String(errorMessage || '').match(/API request failed: (\d+)/);
+  return match ? match[1] : 'unknown';
+}

package/dist/domains/uploads/upload.serializers.js

@@ -0,0 +1,179 @@
+function buildUploadMetadata(options) {
+  let metadata = {
+    ...(options.metadata || {})
+  };
+  let comparison = {
+    ...(metadata.comparison || {})
+  };
+  if (options.threshold !== undefined) {
+    comparison.threshold = options.threshold;
+  }
+  if (options.minClusterSize !== undefined) {
+    comparison.minClusterSize = options.minClusterSize;
+  }
+  if (Object.keys(comparison).length > 0) {
+    metadata.comparison = comparison;
+  }
+  return Object.keys(metadata).length > 0 ? metadata : undefined;
+}
+
+/**
+ * Build API build info payload
+ * @param {Object} options - Upload options
+ * @param {string} [defaultBranch] - Default branch to use
+ * @returns {Object} Build info payload
+ */
+export function buildBuildInfo(options, defaultBranch = 'main') {
+  let buildInfo = {
+    name: options.buildName || `Upload ${new Date().toISOString()}`,
+    branch: options.branch || defaultBranch || 'main',
+    commit_sha: options.commit,
+    commit_message: options.message,
+    commit_author_name: options.commitAuthorName,
+    commit_author_email: options.commitAuthorEmail,
+    environment: options.environment || 'production',
+    threshold: options.threshold,
+    github_pull_request_number: options.pullRequestNumber,
+    parallel_id: options.parallelId
+  };
+  let metadata = buildUploadMetadata(options);
+  if (metadata) {
+    buildInfo.metadata = metadata;
+  }
+  return buildInfo;
+}
+
+/**
+ * Build scanning phase progress
+ * @param {number} total - Total files found
+ * @returns {Object} Progress object
+ */
+export function buildScanningProgress(total) {
+  return {
+    phase: 'scanning',
+    message: `Found ${total} screenshots`,
+    total
+  };
+}
+
+/**
+ * Build processing phase progress
+ * @param {number} current - Current file number
+ * @param {number} total - Total files
+ * @returns {Object} Progress object
+ */
+export function buildProcessingProgress(current, total) {
+  return {
+    phase: 'processing',
+    message: 'Processing files',
+    current,
+    total
+  };
+}
+
+/**
+ * Build deduplication phase progress
+ * @param {number} toUpload - Files to upload
+ * @param {number} existing - Existing files
+ * @param {number} total - Total files
+ * @returns {Object} Progress object
+ */
+export function buildDeduplicationProgress(toUpload, existing, total) {
+  return {
+    phase: 'deduplication',
+    message: `Checking for duplicates (${toUpload} to upload, ${existing} existing)`,
+    toUpload,
+    existing,
+    total
+  };
+}
+
+/**
+ * Build uploading phase progress
+ * @param {number} current - Current upload number
+ * @param {number} total - Total to upload
+ * @returns {Object} Progress object
+ */
+export function buildUploadingProgress(current, total) {
+  return {
+    phase: 'uploading',
+    message: 'Uploading screenshots',
+    current,
+    total
+  };
+}
+
+/**
+ * Build completed phase progress
+ * @param {string} buildId - Build ID
+ * @param {string|null} url - Build URL
+ * @returns {Object} Progress object
+ */
+export function buildCompletedProgress(buildId, url) {
+  return {
+    phase: 'completed',
+    message: 'Upload completed',
+    buildId,
+    url
+  };
+}
+
+/**
+ * Build successful upload result
+ * @param {Object} options - Options
+ * @param {string} options.buildId - Build ID
+ * @param {string|null} options.url - Build URL
+ * @param {number} options.total - Total files
+ * @param {number} options.uploaded - Files uploaded
+ * @param {number} options.skipped - Files skipped
+ * @returns {Object} Upload result
+ */
+export function buildUploadResult({
+  buildId,
+  url,
+  total,
+  uploaded,
+  skipped
+}) {
+  return {
+    success: true,
+    buildId,
+    url,
+    stats: {
+      total,
+      uploaded,
+      skipped
+    }
+  };
+}
+
+/**
+ * Build wait result from build response
+ * @param {Object} build - Build object from API
+ * @returns {Object} Wait result
+ */
+export function buildWaitResult(build) {
+  let totalComparisons = build.total_comparisons;
+  let passedComparisons = build.identical_comparisons;
+  let failedComparisons = build.changed_comparisons;
+  let newComparisons = build.new_comparisons;
+  let identicalComparisons = build.identical_comparisons;
+  let hasComparisonCounts = build.total_comparisons !== undefined || build.new_comparisons !== undefined || build.changed_comparisons !== undefined || build.identical_comparisons !== undefined;
+  let result = {
+    status: build.status,
+    build,
+    passedComparisons,
+    failedComparisons,
+    newComparisons,
+    identicalComparisons,
+    visual_review: build.visual_review || null,
+    totalComparisons
+  };
+  if (hasComparisonCounts) {
+    result.comparisons = totalComparisons;
+  }
+  if (build.url) {
+    result.url = build.url;
+  }
+  return result;
+}