agentpacks 0.3.0 → 0.4.0

package/dist/features/models.d.ts

@@ -0,0 +1,167 @@
+import { z } from 'zod';
+/**
+ * Agent model assignment.
+ */
+export declare const AgentModelSchema: z.ZodObject<{
+    model: z.ZodString;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type AgentModel = z.infer<typeof AgentModelSchema>;
+/**
+ * Model profile — a named preset for default/small model selection.
+ * Supports inheritance via `extends` to compose profiles.
+ */
+export declare const ModelProfileSchema: z.ZodObject<{
+    extends: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    default: z.ZodOptional<z.ZodString>;
+    small: z.ZodOptional<z.ZodString>;
+    agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodString;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ModelProfile = z.infer<typeof ModelProfileSchema>;
+/**
+ * Structured routing condition — richer than simple key=value.
+ * Supports task complexity, urgency, budget, context needs, and tool usage.
+ */
+export declare const RoutingConditionSchema: z.ZodObject<{
+    complexity: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>>;
+    urgency: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        high: "high";
+        normal: "normal";
+    }>>;
+    budget: z.ZodOptional<z.ZodEnum<{
+        minimal: "minimal";
+        standard: "standard";
+        premium: "premium";
+    }>>;
+    contextWindowNeed: z.ZodOptional<z.ZodEnum<{
+        small: "small";
+        medium: "medium";
+        large: "large";
+        max: "max";
+    }>>;
+    toolUseIntensity: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        light: "light";
+        heavy: "heavy";
+    }>>;
+}, z.core.$strip>;
+export type RoutingCondition = z.infer<typeof RoutingConditionSchema>;
+/**
+ * Routing rule — maps task context to a profile.
+ *
+ * `when` accepts either:
+ * - Simple key=value pairs: `{ task: "review", language: "rust" }`
+ * - Structured conditions: `{ complexity: "high", budget: "premium" }`
+ * Both forms can be mixed.
+ */
+export declare const RoutingRuleSchema: z.ZodObject<{
+    when: z.ZodRecord<z.ZodString, z.ZodString>;
+    use: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type RoutingRule = z.infer<typeof RoutingRuleSchema>;
+/**
+ * Provider model options/variants.
+ */
+export declare const ProviderModelSchema: z.ZodObject<{
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare const ProviderConfigSchema: z.ZodObject<{
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ProviderConfig = z.infer<typeof ProviderConfigSchema>;
+/**
+ * Full models.json schema for a pack.
+ */
+export declare const ModelsSchema: z.ZodObject<{
+    default: z.ZodOptional<z.ZodString>;
+    small: z.ZodOptional<z.ZodString>;
+    agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodString;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    profiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        extends: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodString>;
+        small: z.ZodOptional<z.ZodString>;
+        agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            model: z.ZodString;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    routing: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodRecord<z.ZodString, z.ZodString>;
+        use: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        default: z.ZodOptional<z.ZodString>;
+        small: z.ZodOptional<z.ZodString>;
+        agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            model: z.ZodString;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ModelsConfig = z.infer<typeof ModelsSchema>;
+/**
+ * Parsed models configuration from a pack.
+ */
+export interface ParsedModels {
+    packName: string;
+    sourcePath: string;
+    config: ModelsConfig;
+}
+/**
+ * Parse models configuration from a pack's models.json file.
+ */
+export declare function parseModels(packDir: string, packName: string): ParsedModels | null;
+/**
+ * Merge multiple models configs.
+ * Strategy:
+ *   - default, small: first-pack-wins
+ *   - agents: merge by name, first-pack-wins per agent
+ *   - profiles: additive (unique name), first-pack-wins on name conflict
+ *   - providers: deep merge by provider key, first-pack-wins on scalar conflicts
+ *   - routing: additive with original order preserved
+ *   - overrides: first-pack-wins per target key
+ */
+export declare function mergeModelsConfigs(configs: ParsedModels[]): {
+    config: ModelsConfig;
+    warnings: string[];
+};
+/**
+ * Scan a models config for potential secrets/credentials.
+ * Returns an array of warning messages for each detected secret.
+ */
+export declare function scanModelsForSecrets(config: ModelsConfig): string[];

package/dist/features/models.js

@@ -0,0 +1,293 @@
+// @bun
+var __require = import.meta.require;
+
+// src/utils/filesystem.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  readdirSync,
+  rmSync,
+  statSync
+} from "fs";
+import { dirname, relative, join } from "path";
+var GENERATED_HEADER_MD = "<!-- Generated by agentpacks. DO NOT EDIT. -->";
+var GENERATED_HEADER_JSON = "// Generated by agentpacks. DO NOT EDIT.";
+var GENERATED_HEADER_JS = "// Generated by agentpacks. DO NOT EDIT.";
+function writeGeneratedFile(filepath, content, options = {}) {
+  const { header = true, type } = options;
+  const ext = type ?? inferFileType(filepath);
+  ensureDir(dirname(filepath));
+  let output = content;
+  if (header) {
+    const headerComment = getHeader(ext);
+    if (headerComment) {
+      output = `${headerComment}
+${content}`;
+    }
+  }
+  writeFileSync(filepath, output, "utf-8");
+}
+function writeGeneratedJson(filepath, data, options = {}) {
+  const json = JSON.stringify(data, null, 2);
+  writeGeneratedFile(filepath, json + `
+`, { ...options, type: "json" });
+}
+function readFileOrNull(filepath) {
+  if (!existsSync(filepath))
+    return null;
+  return readFileSync(filepath, "utf-8");
+}
+function readJsonOrNull(filepath) {
+  const content = readFileOrNull(filepath);
+  if (content === null)
+    return null;
+  return JSON.parse(content);
+}
+function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+}
+function removeIfExists(targetPath) {
+  if (existsSync(targetPath)) {
+    rmSync(targetPath, { recursive: true, force: true });
+  }
+}
+function listFiles(dirPath, options = {}) {
+  const { extension, recursive = false } = options;
+  if (!existsSync(dirPath))
+    return [];
+  const results = [];
+  const entries = readdirSync(dirPath);
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory() && recursive) {
+      results.push(...listFiles(fullPath, options));
+    } else if (stat.isFile()) {
+      if (!extension || entry.endsWith(extension)) {
+        results.push(fullPath);
+      }
+    }
+  }
+  return results;
+}
+function listDirs(dirPath) {
+  if (!existsSync(dirPath))
+    return [];
+  return readdirSync(dirPath).map((entry) => join(dirPath, entry)).filter((fullPath) => statSync(fullPath).isDirectory());
+}
+function relPath(projectRoot, filepath) {
+  return relative(projectRoot, filepath);
+}
+function isGeneratedFile(filepath) {
+  const content = readFileOrNull(filepath);
+  if (!content)
+    return false;
+  return content.startsWith(GENERATED_HEADER_MD) || content.startsWith(GENERATED_HEADER_JSON) || content.startsWith(GENERATED_HEADER_JS);
+}
+function inferFileType(filepath) {
+  if (filepath.endsWith(".json") || filepath.endsWith(".jsonc"))
+    return "json";
+  if (filepath.endsWith(".ts") || filepath.endsWith(".mts"))
+    return "ts";
+  if (filepath.endsWith(".js") || filepath.endsWith(".mjs"))
+    return "js";
+  return "md";
+}
+function getHeader(type) {
+  switch (type) {
+    case "md":
+      return GENERATED_HEADER_MD;
+    case "json":
+      return GENERATED_HEADER_JSON;
+    case "js":
+    case "ts":
+      return GENERATED_HEADER_JS;
+    default:
+      return null;
+  }
+}
+
+// src/features/models.ts
+import { join as join2 } from "path";
+import { z } from "zod";
+var SECRET_PATTERNS = [
+  /["']api[_-]?key["']\s*:/i,
+  /["']apiKey["']\s*:/i,
+  /["']secret["']\s*:/i,
+  /["']password["']\s*:/i,
+  /["'](?:auth_token|access_token|bearer_token)["']\s*:/i,
+  /["']private[_-]?key["']\s*:/i,
+  /-----BEGIN\s+(RSA|EC|DSA|OPENSSH|PGP)\s+PRIVATE\s+KEY-----/,
+  /sk-[a-zA-Z0-9]{20,}/,
+  /Bearer\s+[a-zA-Z0-9._-]{20,}/
+];
+var AgentModelSchema = z.object({
+  model: z.string(),
+  temperature: z.number().min(0).max(2).optional(),
+  top_p: z.number().min(0).max(1).optional()
+});
+var ModelProfileSchema = z.object({
+  extends: z.string().optional(),
+  description: z.string().optional(),
+  default: z.string().optional(),
+  small: z.string().optional(),
+  agents: z.record(z.string(), AgentModelSchema).optional()
+});
+var RoutingConditionSchema = z.object({
+  complexity: z.enum(["low", "medium", "high", "critical"]).optional().describe("Task complexity level"),
+  urgency: z.enum(["low", "normal", "high"]).optional().describe("Time sensitivity"),
+  budget: z.enum(["minimal", "standard", "premium"]).optional().describe("Cost/token budget tier"),
+  contextWindowNeed: z.enum(["small", "medium", "large", "max"]).optional().describe("Required context window size"),
+  toolUseIntensity: z.enum(["none", "light", "heavy"]).optional().describe("Expected tool/function calling intensity")
+});
+var RoutingRuleSchema = z.object({
+  when: z.record(z.string(), z.string()),
+  use: z.string(),
+  description: z.string().optional(),
+  priority: z.number().optional()
+});
+var ProviderModelSchema = z.object({
+  options: z.record(z.string(), z.unknown()).optional(),
+  variants: z.record(z.string(), z.record(z.string(), z.unknown())).optional()
+});
+var ProviderConfigSchema = z.object({
+  options: z.record(z.string(), z.unknown()).optional(),
+  models: z.record(z.string(), ProviderModelSchema).optional()
+});
+var ModelsSchema = z.object({
+  default: z.string().optional(),
+  small: z.string().optional(),
+  agents: z.record(z.string(), AgentModelSchema).optional(),
+  profiles: z.record(z.string(), ModelProfileSchema).optional(),
+  providers: z.record(z.string(), ProviderConfigSchema).optional(),
+  routing: z.array(RoutingRuleSchema).optional(),
+  overrides: z.record(z.string(), z.object({
+    default: z.string().optional(),
+    small: z.string().optional(),
+    agents: z.record(z.string(), AgentModelSchema).optional()
+  })).optional()
+});
+function parseModels(packDir, packName) {
+  const modelsPath = join2(packDir, "models.json");
+  const raw = readJsonOrNull(modelsPath);
+  if (!raw)
+    return null;
+  const parsed = ModelsSchema.parse(raw);
+  return {
+    packName,
+    sourcePath: modelsPath,
+    config: parsed
+  };
+}
+function mergeModelsConfigs(configs) {
+  const warnings = [];
+  const result = {};
+  for (const entry of configs) {
+    const { config, packName } = entry;
+    if (config.default !== undefined && result.default === undefined) {
+      result.default = config.default;
+    } else if (config.default !== undefined && result.default !== undefined) {
+      warnings.push(`Models "default" from pack "${packName}" skipped (already defined).`);
+    }
+    if (config.small !== undefined && result.small === undefined) {
+      result.small = config.small;
+    } else if (config.small !== undefined && result.small !== undefined) {
+      warnings.push(`Models "small" from pack "${packName}" skipped (already defined).`);
+    }
+    if (config.agents) {
+      if (!result.agents)
+        result.agents = {};
+      for (const [name, assignment] of Object.entries(config.agents)) {
+        if (name in result.agents) {
+          warnings.push(`Models agent "${name}" from pack "${packName}" skipped (already defined).`);
+          continue;
+        }
+        result.agents[name] = assignment;
+      }
+    }
+    if (config.profiles) {
+      if (!result.profiles)
+        result.profiles = {};
+      for (const [name, profile] of Object.entries(config.profiles)) {
+        if (name in result.profiles) {
+          warnings.push(`Models profile "${name}" from pack "${packName}" skipped (already defined).`);
+          continue;
+        }
+        result.profiles[name] = profile;
+      }
+    }
+    if (config.providers) {
+      if (!result.providers)
+        result.providers = {};
+      for (const [providerName, providerConfig] of Object.entries(config.providers)) {
+        if (!(providerName in result.providers)) {
+          result.providers[providerName] = providerConfig;
+        } else {
+          const existing = result.providers[providerName];
+          if (!existing) {
+            result.providers[providerName] = providerConfig;
+            continue;
+          }
+          if (providerConfig.options) {
+            existing.options = {
+              ...providerConfig.options,
+              ...existing.options
+            };
+          }
+          if (providerConfig.models) {
+            if (!existing.models)
+              existing.models = {};
+            for (const [modelName, modelConfig] of Object.entries(providerConfig.models)) {
+              if (!(modelName in existing.models)) {
+                existing.models[modelName] = modelConfig;
+              }
+            }
+          }
+        }
+      }
+    }
+    if (config.routing) {
+      if (!result.routing)
+        result.routing = [];
+      result.routing.push(...config.routing);
+    }
+    if (config.overrides) {
+      if (!result.overrides)
+        result.overrides = {};
+      for (const [targetId, override] of Object.entries(config.overrides)) {
+        if (targetId in result.overrides) {
+          warnings.push(`Models override for target "${targetId}" from pack "${packName}" skipped (already defined).`);
+          continue;
+        }
+        result.overrides[targetId] = override;
+      }
+    }
+  }
+  return { config: result, warnings };
+}
+function scanModelsForSecrets(config) {
+  const warnings = [];
+  const json = JSON.stringify(config);
+  for (const pattern of SECRET_PATTERNS) {
+    if (pattern.test(json)) {
+      warnings.push(`Potential secret detected in models.json matching pattern: ${pattern.source}`);
+    }
+  }
+  return warnings;
+}
+export {
+  scanModelsForSecrets,
+  parseModels,
+  mergeModelsConfigs,
+  RoutingRuleSchema,
+  RoutingConditionSchema,
+  ProviderModelSchema,
+  ProviderConfigSchema,
+  ModelsSchema,
+  ModelProfileSchema,
+  AgentModelSchema
+};

package/dist/features/plugins.js

@@ -1,32 +1,4 @@
 // @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // src/utils/filesystem.ts
@@ -36,10 +8,10 @@ import {
   readFileSync,
   writeFileSync,
   readdirSync,
+  rmSync,
   statSync
 } from "fs";
 import { dirname, relative, join } from "path";
-import { removeSync } from "fs-extra";
 var GENERATED_HEADER_MD = "<!-- Generated by agentpacks. DO NOT EDIT. -->";
 var GENERATED_HEADER_JSON = "// Generated by agentpacks. DO NOT EDIT.";
 var GENERATED_HEADER_JS = "// Generated by agentpacks. DO NOT EDIT.";
@@ -80,7 +52,7 @@ function ensureDir(dirPath) {
 }
 function removeIfExists(targetPath) {
   if (existsSync(targetPath)) {
-    removeSync(targetPath);
+    rmSync(targetPath, { recursive: true, force: true });
   }
 }
 function listFiles(dirPath, options = {}) {

package/dist/features/rules.js

@@ -1,32 +1,4 @@
 // @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // src/utils/filesystem.ts
@@ -36,10 +8,10 @@ import {
   readFileSync,
   writeFileSync,
   readdirSync,
+  rmSync,
   statSync
 } from "fs";
 import { dirname, relative, join } from "path";
-import { removeSync } from "fs-extra";
 var GENERATED_HEADER_MD = "<!-- Generated by agentpacks. DO NOT EDIT. -->";
 var GENERATED_HEADER_JSON = "// Generated by agentpacks. DO NOT EDIT.";
 var GENERATED_HEADER_JS = "// Generated by agentpacks. DO NOT EDIT.";
@@ -80,7 +52,7 @@ function ensureDir(dirPath) {
 }
 function removeIfExists(targetPath) {
   if (existsSync(targetPath)) {
-    removeSync(targetPath);
+    rmSync(targetPath, { recursive: true, force: true });
   }
 }
 function listFiles(dirPath, options = {}) {

package/dist/features/skills.js

@@ -1,32 +1,4 @@
 // @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // src/utils/filesystem.ts
@@ -36,10 +8,10 @@ import {
   readFileSync,
   writeFileSync,
   readdirSync,
+  rmSync,
   statSync
 } from "fs";
 import { dirname, relative, join } from "path";
-import { removeSync } from "fs-extra";
 var GENERATED_HEADER_MD = "<!-- Generated by agentpacks. DO NOT EDIT. -->";
 var GENERATED_HEADER_JSON = "// Generated by agentpacks. DO NOT EDIT.";
 var GENERATED_HEADER_JS = "// Generated by agentpacks. DO NOT EDIT.";
@@ -80,7 +52,7 @@ function ensureDir(dirPath) {
 }
 function removeIfExists(targetPath) {
   if (existsSync(targetPath)) {
-    removeSync(targetPath);
+    rmSync(targetPath, { recursive: true, force: true });
   }
 }
 function listFiles(dirPath, options = {}) {