skillshop 2.2.0 → 4.1.0

package/src/github-library.js

@@ -0,0 +1,322 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  commitDownloadedPersonalSkill,
+  initPersonalLibrary,
+  inspectPersonalLibrary,
+  libraryConfigFileName,
+  libraryOriginsFileName,
+  librarySelectionFileName,
+  readPersonalLibraryOrigins,
+  selectedLibraryRoot,
+  validatePersonalSkillDirectory
+} from './personal-library.js';
+
+const githubOwnerPattern = /^[A-Za-z0-9-]+$/;
+const skillNamePattern = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const reservedRootNames = new Set([libraryConfigFileName, 'README.md', libraryOriginsFileName]);
+
+export class GitHubLibraryError extends Error {}
+
+function fail(message) {
+  return new GitHubLibraryError(message);
+}
+
+export function parseGitHubSkillReference(reference) {
+  if (typeof reference !== 'string') throw fail('expected GitHub skill reference @<owner>/<skill>');
+  if (!reference.startsWith('@')) {
+    throw fail(`invalid GitHub skill reference ${reference}; prefix remote references with @ as @<owner>/<skill>`);
+  }
+  const parts = reference.slice(1).split('/');
+  if (parts.length !== 2 || !githubOwnerPattern.test(parts[0]) || !skillNamePattern.test(parts[1])) {
+    throw fail(`invalid GitHub skill reference ${reference}; expected @<owner>/<skill>`);
+  }
+  return { owner: parts[0], name: parts[1], repository: `https://github.com/${parts[0]}/skillshop-library.git` };
+}
+
+function gitEnvironment() {
+  return {
+    ...process.env,
+    GIT_TERMINAL_PROMPT: '0',
+    GIT_CONFIG_NOSYSTEM: '1',
+    GIT_CONFIG_GLOBAL: '/dev/null',
+    GIT_ALLOW_PROTOCOL: 'https:file'
+  };
+}
+
+function git(args, { cwd, encoding = 'utf8', maxBuffer = 64 * 1024 * 1024 } = {}) {
+  const result = spawnSync('git', args, { cwd, encoding, env: gitEnvironment(), maxBuffer });
+  if (result.error) throw fail(`could not run Git: ${result.error.message}`);
+  if (result.status !== 0) {
+    const message = encoding === null ? result.stderr?.toString('utf8') : result.stderr;
+    throw fail(`Git ${args[0]} failed${message?.trim() ? `: ${message.trim()}` : ''}`);
+  }
+  return result.stdout;
+}
+
+function parseTreeEntries(buffer) {
+  const decoder = new TextDecoder('utf-8', { fatal: true });
+  const entries = [];
+  for (const chunk of buffer.toString('binary').split('\0').filter(Boolean)) {
+    const separator = chunk.indexOf('\t');
+    if (separator < 0) throw fail('Git returned a malformed tree entry');
+    const [mode, type, object] = chunk.slice(0, separator).split(' ');
+    const rawPath = Buffer.from(chunk.slice(separator + 1), 'binary');
+    let entryPath;
+    try {
+      entryPath = decoder.decode(rawPath);
+    } catch {
+      throw fail('repository contains a non-UTF-8 path');
+    }
+    entries.push({ mode, type, object, path: entryPath });
+  }
+  return entries;
+}
+
+function literalPath(value) {
+  return `:(literal)${value}`;
+}
+
+function treeEntry(repositoryDir, commit, filePath) {
+  const result = git(['-C', repositoryDir, 'ls-tree', '-z', commit, '--', literalPath(filePath)], { encoding: null });
+  const entries = parseTreeEntries(result);
+  return entries.find((entry) => entry.path === filePath) ?? null;
+}
+
+function normalizeSkillsDirectory(value) {
+  if (typeof value !== 'string' || !value || value.includes('\\') || value.startsWith('/')) {
+    throw fail('skillshop-library.json skillsDirectory must be a relative repository path');
+  }
+  const normalized = path.posix.normalize(value);
+  if (normalized === '..' || normalized.startsWith('../') || normalized.startsWith('/')) {
+    throw fail('skillshop-library.json skillsDirectory contains an unsafe path');
+  }
+  return normalized;
+}
+
+function readRemoteConfig(repositoryDir, commit) {
+  const entry = treeEntry(repositoryDir, commit, libraryConfigFileName);
+  if (!entry || entry.type !== 'blob' || !['100644', '100755'].includes(entry.mode)) {
+    throw fail(`repository is missing a regular ${libraryConfigFileName}`);
+  }
+  let config;
+  try {
+    config = JSON.parse(git(['-C', repositoryDir, 'show', `${commit}:${libraryConfigFileName}`], { encoding: null }).toString('utf8'));
+  } catch (error) {
+    if (error instanceof GitHubLibraryError) throw error;
+    throw fail(`cannot parse ${libraryConfigFileName}: ${error.message}`);
+  }
+  if (config?.schemaVersion !== 1) throw fail(`${libraryConfigFileName} has an unsupported schemaVersion`);
+  const skillsDirectory = normalizeSkillsDirectory(config.skillsDirectory);
+  return { skillsDirectory };
+}
+
+function safeRelativeFilePath(skillPath, repoPath) {
+  if (!repoPath.startsWith(`${skillPath}/`)) throw fail(`repository path escapes requested skill: ${repoPath}`);
+  const relative = repoPath.slice(skillPath.length + 1);
+  const parts = relative.split('/');
+  if (!relative || relative.includes('\\') || parts.some((part) => !part || part === '.' || part === '..')) {
+    throw fail(`repository contains an unsafe skill path: ${repoPath}`);
+  }
+  return relative;
+}
+
+function stageSkill(repositoryDir, commit, skillPath, name, stagingRoot) {
+  const rootEntry = treeEntry(repositoryDir, commit, skillPath);
+  if (!rootEntry) throw fail(`repository has no skill named ${name}`);
+  if (rootEntry.mode !== '040000' || rootEntry.type !== 'tree') {
+    throw fail(`repository path for ${name} is not a skill directory`);
+  }
+  const entries = parseTreeEntries(git([
+    '-C', repositoryDir, 'ls-tree', '-r', '-z', '--full-tree', commit, '--', literalPath(skillPath)
+  ], { encoding: null }));
+  if (!entries.length) throw fail(`repository skill ${name} is empty`);
+
+  const skillDirectory = path.join(stagingRoot, 'skill');
+  fs.mkdirSync(skillDirectory, { recursive: true, mode: 0o755 });
+  const seen = new Set();
+  for (const entry of entries) {
+    const relative = safeRelativeFilePath(skillPath, entry.path);
+    if (seen.has(relative)) throw fail(`repository contains a duplicate skill path: ${relative}`);
+    seen.add(relative);
+    if (entry.type !== 'blob' || !['100644', '100755'].includes(entry.mode)) {
+      throw fail(`repository skill contains a symlink, submodule, or non-regular entry: ${entry.path}`);
+    }
+    const target = path.join(skillDirectory, ...relative.split('/'));
+    const contained = path.relative(skillDirectory, target);
+    if (contained === '..' || contained.startsWith(`..${path.sep}`) || path.isAbsolute(contained)) {
+      throw fail(`repository path escapes requested skill: ${entry.path}`);
+    }
+    fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o755 });
+    const contents = git(['-C', repositoryDir, 'cat-file', 'blob', entry.object], { encoding: null });
+    fs.writeFileSync(target, contents, { flag: 'wx', mode: entry.mode === '100755' ? 0o755 : 0o644 });
+    fs.chmodSync(target, entry.mode === '100755' ? 0o755 : 0o644);
+  }
+  validatePersonalSkillDirectory(skillDirectory, skillDirectory, name);
+  return skillDirectory;
+}
+
+function fetchSkill(reference, temporaryRoot, { ref = null, commit: expectedCommit = null } = {}) {
+  const bareRepository = path.join(temporaryRoot, 'repository.git');
+  fs.mkdirSync(bareRepository, { recursive: true });
+  git(['init', '--bare', '--quiet', bareRepository]);
+  let fetchRef = expectedCommit ?? ref;
+  if (expectedCommit && !/^[a-f0-9]{40,64}$/.test(expectedCommit)) throw fail('invalid locked commit identifier');
+  if (fetchRef) {
+    if (typeof fetchRef !== 'string' || fetchRef.startsWith('-')) throw fail('invalid Git skill ref');
+    if (!/^[a-f0-9]{40,64}$/.test(fetchRef)) git(['check-ref-format', '--allow-onelevel', fetchRef]);
+  } else {
+    const symbolicRefs = git(['ls-remote', '--symref', reference.repository, 'HEAD']);
+    const headReference = symbolicRefs.split(/\r?\n/).find((line) => line.startsWith('ref: ') && line.endsWith('\tHEAD'));
+    const headObject = symbolicRefs.split(/\r?\n/).find((line) => /^[a-f0-9]{40,64}\tHEAD$/.test(line));
+    if (!headReference || !headObject) throw fail(`could not discover the default branch for ${reference.repository}`);
+    fetchRef = headReference.slice('ref: '.length, -'\tHEAD'.length);
+    if (!fetchRef.startsWith('refs/heads/')) throw fail('GitHub repository default is not a branch');
+    git(['-C', bareRepository, 'check-ref-format', fetchRef]);
+  }
+  git(['-C', bareRepository, 'fetch', '--no-tags', '--no-recurse-submodules', '--depth=1', reference.repository, fetchRef]);
+  const commit = git(['-C', bareRepository, 'rev-parse', '--verify', 'FETCH_HEAD^{commit}']).trim();
+  if (!/^[a-f0-9]{40,64}$/.test(commit)) throw fail('Git returned an invalid commit identifier');
+  if (expectedCommit && commit !== expectedCommit) throw fail(`fetched commit does not match locked commit ${expectedCommit}`);
+  const config = readRemoteConfig(bareRepository, commit);
+  const skillPath = config.skillsDirectory === '.' ? reference.name : `${config.skillsDirectory}/${reference.name}`;
+  if (config.skillsDirectory === '.' && reservedRootNames.has(reference.name)) {
+    throw fail(`skill name collides with repository metadata: ${reference.name}`);
+  }
+  const skillDirectory = stageSkill(bareRepository, commit, skillPath, reference.name, temporaryRoot);
+  return { skillDirectory, origin: { repository: reference.repository, commit } };
+}
+
+export function fetchGitHubSkill(reference, temporaryRoot, options = {}) {
+  return fetchSkill(parseGitHubSkillReference(reference), temporaryRoot, options);
+}
+
+function snapshotFile(filePath) {
+  try {
+    const stat = fs.lstatSync(filePath);
+    if (!stat.isFile() || stat.isSymbolicLink()) throw fail(`${filePath} must be a regular file`);
+    return { contents: fs.readFileSync(filePath), mode: stat.mode & 0o777 };
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+function restoreFile(filePath, snapshot) {
+  if (!snapshot) {
+    fs.rmSync(filePath, { force: true });
+    return;
+  }
+  fs.writeFileSync(filePath, snapshot.contents, { mode: snapshot.mode });
+  fs.chmodSync(filePath, snapshot.mode);
+}
+
+function captureInitialization(root, stateHome) {
+  let rootExisted = true;
+  let rootEmpty = false;
+  try {
+    const stat = fs.lstatSync(root);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) throw fail(`library root is not a regular directory: ${root}`);
+    rootEmpty = fs.readdirSync(root).length === 0;
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+    rootExisted = false;
+  }
+  const skillsBefore = path.join(root, 'skills');
+  let skillsExisted = false;
+  try {
+    fs.lstatSync(skillsBefore);
+    skillsExisted = true;
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+  return {
+    rootExisted,
+    rootEmpty,
+    skillsExisted,
+    stateHomeExisted: fs.existsSync(stateHome),
+    config: snapshotFile(path.join(root, libraryConfigFileName)),
+    readme: snapshotFile(path.join(root, 'README.md')),
+    selection: snapshotFile(path.join(stateHome, librarySelectionFileName))
+  };
+}
+
+function rollbackInitialization(root, stateHome, snapshot) {
+  if (!snapshot.rootExisted) {
+    fs.rmSync(root, { recursive: true, force: true });
+  } else if (snapshot.rootEmpty) {
+    for (const entry of fs.readdirSync(root)) fs.rmSync(path.join(root, entry), { recursive: true, force: true });
+  } else {
+    restoreFile(path.join(root, libraryConfigFileName), snapshot.config);
+    restoreFile(path.join(root, 'README.md'), snapshot.readme);
+    if (!snapshot.skillsExisted) fs.rmSync(path.join(root, 'skills'), { recursive: true, force: true });
+  }
+  restoreFile(path.join(stateHome, librarySelectionFileName), snapshot.selection);
+  if (!snapshot.stateHomeExisted && fs.existsSync(stateHome) && fs.readdirSync(stateHome).length === 0) {
+    fs.rmdirSync(stateHome);
+  }
+}
+
+function targetInfo(layout, name) {
+  if (path.resolve(layout.skillsDirectory) === path.resolve(layout.root) && reservedRootNames.has(name)) {
+    throw fail(`skill name collides with library metadata: ${name}`);
+  }
+  const target = path.join(layout.skillsDirectory, name);
+  try {
+    const stat = fs.lstatSync(target);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) throw fail(`personal library target is not a regular skill directory: ${target}`);
+    validatePersonalSkillDirectory(layout.root, target, name);
+    return { target, exists: true };
+  } catch (error) {
+    if (error.code === 'ENOENT') return { target, exists: false };
+    throw error;
+  }
+}
+
+export function downloadPersonalSkill(referenceValue, { stateHome, templateRoot, force = false } = {}) {
+  const reference = parseGitHubSkillReference(referenceValue);
+  const selected = selectedLibraryRoot(stateHome);
+  const root = selected ?? path.resolve(os.homedir(), 'skillshop-library');
+  const layout = inspectPersonalLibrary(root);
+  const origins = layout.exists ? readPersonalLibraryOrigins(root) : { schemaVersion: 1, skills: {} };
+  const existingOrigin = origins.skills[reference.name];
+  const target = targetInfo(layout, reference.name);
+  if (target.exists && !force) {
+    if (existingOrigin?.repository === reference.repository) {
+      if (!selected) initPersonalLibrary(root, stateHome, templateRoot);
+      return { root, name: reference.name, origin: existingOrigin, alreadyPresent: true };
+    }
+    if (existingOrigin) throw fail(`${reference.name} already has a different GitHub source; use --force to replace it`);
+    throw fail(`${reference.name} already exists as a personal skill; use --force to replace it`);
+  }
+  if (existingOrigin && existingOrigin.repository !== reference.repository && !force) {
+    throw fail(`${reference.name} already has a different GitHub source; use --force to replace it`);
+  }
+  const temporaryRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'skillshop-github-download-'));
+  try {
+    const downloaded = fetchSkill(reference, temporaryRoot);
+    let initialized = false;
+    let initializationSnapshot;
+    let skillsDirectory = layout.skillsDirectory;
+    if (!selected) initializationSnapshot = captureInitialization(root, stateHome);
+    try {
+      if (!selected) {
+        initialized = true;
+        const result = initPersonalLibrary(root, stateHome, templateRoot, { includeExample: false });
+        skillsDirectory = result.skillsDirectory;
+        if (path.resolve(skillsDirectory) !== path.resolve(layout.skillsDirectory)) {
+          throw fail('default library layout changed during download');
+        }
+      }
+      const committed = commitDownloadedPersonalSkill(root, skillsDirectory, reference.name, downloaded.skillDirectory, downloaded.origin, { force });
+      return { root, name: reference.name, origin: downloaded.origin, target: committed.target, alreadyPresent: false };
+    } catch (error) {
+      if (initialized) rollbackInitialization(root, stateHome, initializationSnapshot);
+      throw error;
+    }
+  } finally {
+    fs.rmSync(temporaryRoot, { recursive: true, force: true });
+  }
+}

package/src/import.js

@@ -5,6 +5,7 @@ import { createRequire } from 'node:module';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { normalizeSkillSpecifier, parseSkillSpecifier, parseLibrarySkillReference } from './specifier.js';
 import { SKILLSHOP_MANIFEST_FILE, SKILLSHOP_SCHEMA_VERSION } from './library.js';
+import { assertInstallationOwner, writeInstallationManifest } from './installation-state.js';
 
 async function importManifestFile(file) {
   // Content-based cache keys also invalidate in long-lived consumers when two
@@ -95,11 +96,23 @@ export async function importSkill({
   cwd = process.cwd(),
   overwrite = false,
   merge = false,
+  ownerKind = 'package-import',
 }) {
   if (targetDir !== undefined && (typeof targetDir !== 'string' || !targetDir.trim())) throw new Error('targetDir must be a nonempty path');
   if (merge && overwrite) throw new Error('merge and overwrite cannot both be enabled');
   const skill = await resolveSkill({ reference, library, specifier, cwd });
   const target = path.resolve(cwd, targetDir ?? path.join('.agents', 'skills', skill.name));
+  const source = path.resolve(skill.sourceDir);
+  if ([path.relative(source, target), path.relative(target, source)].some((relative) => relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative)))) {
+    throw new Error('skill import destination overlaps its source directory');
+  }
+  listSkillFiles(skill.sourceDir);
+  const owner = { kind: ownerKind, id: skill.packageName || skill.sourceDir };
+  const installation = assertInstallationOwner(path.dirname(target), path.basename(target), owner);
+  const saveOwnership = () => {
+    installation.skills[path.basename(target)] = { owner, source: { kind: 'package', package: skill.packageName, specifier: skill.specifier } };
+    writeInstallationManifest(path.dirname(target), installation);
+  };
   const exists = fs.existsSync(target);
 
   if (exists && merge) {
@@ -121,6 +134,7 @@ export async function importSkill({
         addedFiles += 1;
       }
     }
+    saveOwnership();
     return { ...skill, targetDir: target, installed: addedFiles > 0, updated: updatedFiles > 0, addedFiles, updatedFiles };
   }
 
@@ -132,6 +146,7 @@ export async function importSkill({
     fs.cpSync(skill.sourceDir, temporary, { recursive: true, force: true });
     if (overwrite) fs.rmSync(target, { recursive: true, force: true });
     fs.renameSync(temporary, target);
+    saveOwnership();
   } finally {
     fs.rmSync(temporary, { recursive: true, force: true });
   }

package/src/index.js

@@ -3,3 +3,5 @@ export * from './library.js';
 export * from './export.js';
 export * from './import.js';
 export * from './user-install.js';
+export * from './dependencies.js';
+export * from './installation-state.js';

package/src/installation-state.js

@@ -0,0 +1,113 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+export const installationManifestName = '.skillshop-lock';
+const skillNamePattern = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+
+export function assertRegularPath(target) {
+  const absolute = path.resolve(target);
+  let current = path.parse(absolute).root;
+  for (const segment of absolute.slice(current.length).split(path.sep).filter(Boolean)) {
+    current = path.join(current, segment);
+    try {
+      // macOS exposes its system temporary directories through these aliases.
+      const systemAlias = process.platform === 'darwin' && ['/var', '/tmp'].includes(current);
+      if (fs.lstatSync(current).isSymbolicLink() && !systemAlias) throw new Error(`installation path contains a symlink: ${current}`);
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+    }
+  }
+}
+
+export function atomicJson(file, value) {
+  assertRegularPath(file);
+  const contents = `${JSON.stringify(value, null, 2)}\n`;
+  if (fs.existsSync(file) && fs.readFileSync(file, 'utf8') === contents) return;
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.tmp-${randomUUID()}`;
+  try {
+    fs.writeFileSync(temporary, contents, { flag: 'wx' });
+    fs.renameSync(temporary, file);
+  } finally {
+    fs.rmSync(temporary, { force: true });
+  }
+}
+
+export function sameOwner(left, right) {
+  return left?.kind === right?.kind && left?.id === right?.id;
+}
+
+export function readInstallationManifest(directory) {
+  const file = path.join(directory, installationManifestName);
+  assertRegularPath(file);
+  if (!fs.existsSync(file)) return { manifestVersion: 1, skills: {} };
+  let manifest;
+  try { manifest = JSON.parse(fs.readFileSync(file, 'utf8')); }
+  catch (error) { throw new Error(`cannot parse ${file}: ${error.message}`); }
+  if (manifest?.manifestVersion !== 1 || !manifest.skills || typeof manifest.skills !== 'object' || Array.isArray(manifest.skills)) {
+    throw new Error(`${file} is not a supported Skillshop installation manifest`);
+  }
+  for (const [name, entry] of Object.entries(manifest.skills)) {
+    if (!skillNamePattern.test(name) || !entry || typeof entry !== 'object' ||
+        typeof entry.owner?.kind !== 'string' || !entry.owner.kind || typeof entry.owner?.id !== 'string' || !entry.owner.id) {
+      throw new Error(`${file} has an invalid ownership entry for ${name}`);
+    }
+  }
+  return manifest;
+}
+
+export function writeInstallationManifest(directory, manifest) {
+  atomicJson(path.join(directory, installationManifestName), {
+    manifestVersion: 1,
+    skills: Object.fromEntries(Object.entries(manifest.skills).sort(([a], [b]) => a.localeCompare(b)))
+  });
+}
+
+export function assertInstallationOwner(directory, name, owner, { requireOwned = false } = {}) {
+  if (!skillNamePattern.test(name)) throw new Error(`invalid skill name: ${name}`);
+  const target = path.join(directory, name);
+  assertRegularPath(target);
+  const manifest = readInstallationManifest(directory);
+  const existing = manifest.skills[name];
+  if (existing && !sameOwner(existing.owner, owner)) {
+    throw new Error(`${target} is owned by ${existing.owner.kind}:${existing.owner.id}; refusing to replace or remove it`);
+  }
+  if (!existing && (requireOwned || fs.existsSync(target))) {
+    throw new Error(`${target} exists or was requested for removal but is not a Skillshop-managed copy owned by ${owner.kind}:${owner.id}`);
+  }
+  return manifest;
+}
+
+export function stateHome() {
+  if (process.env.SKILLSHOP_HOME) return process.env.SKILLSHOP_HOME;
+  if (process.env.SKILLZ_HOME) return process.env.SKILLZ_HOME;
+  const current = path.join(os.homedir(), '.skillshop');
+  const legacy = path.join(os.homedir(), '.skillz');
+  return fs.existsSync(current) || !fs.existsSync(legacy) ? current : legacy;
+}
+
+export function readInstallationIndex(home = stateHome()) {
+  const file = path.join(home, 'installations.json');
+  assertRegularPath(file);
+  if (!fs.existsSync(file)) return [];
+  let index;
+  try { index = JSON.parse(fs.readFileSync(file, 'utf8')); }
+  catch (error) { throw new Error(`cannot parse ${file}: ${error.message}`); }
+  if (index?.indexVersion !== 1 || !Array.isArray(index.installations) || index.installations.some((entry) =>
+    !entry || !path.isAbsolute(entry.directory ?? '') || !['project', 'global'].includes(entry.scope) ||
+    (entry.scope === 'project' && !path.isAbsolute(entry.root ?? '')))) {
+    throw new Error(`${file} is not a supported installation discovery index`);
+  }
+  return index.installations;
+}
+
+export function registerInstallationDirectory(directory, { root = null, home = stateHome() } = {}) {
+  const entry = root ? { directory: path.resolve(directory), scope: 'project', root: path.resolve(root) }
+    : { directory: path.resolve(directory), scope: 'global' };
+  const entries = readInstallationIndex(home).filter((item) => item.directory !== entry.directory);
+  entries.push(entry);
+  entries.sort((a, b) => a.directory.localeCompare(b.directory));
+  atomicJson(path.join(home, 'installations.json'), { indexVersion: 1, installations: entries });
+}