@lynxflow/seo-engine 2.8.0 → 3.2.0

package/dist/inventory-scarcity-engine.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Inventory Scarcity & Social Proof Engine
+ * Calcul d'urgence de stock et simulation de preuve sociale temps réel pour e-commerce.
+ */
+export interface ProductInventoryState {
+    productId: string;
+    variantId: string;
+    inventoryQuantity: number;
+    lowStockThreshold?: number;
+    recentOrdersCount24h?: number;
+    activeViewersCount?: number;
+}
+export interface ScarcitySignalResult {
+    hasUrgency: boolean;
+    urgencyType: "low_stock" | "high_demand" | "flash_scarcity" | "none";
+    scarcityMessage: string;
+    badgeLabel?: string;
+    badgeTone: "danger" | "warning" | "neutral";
+    remainingQuantity: number;
+}
+export declare class InventoryScarcityEngine {
+    /**
+     * Évalue le niveau d'urgence d'un produit selon son stock et sa vélocité
+     */
+    static evaluateScarcity(state: ProductInventoryState): ScarcitySignalResult;
+    /**
+     * Formate un message d'événement de vente récente (Live Sales Ticker)
+     */
+    static formatLivePurchaseNotification(buyerName: string, city: string, productTitle: string, minutesAgo: number): string;
+}

package/dist/iptc-media-validator.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 🖼️ IPTC PhotoMetadata & AI-Generated Media Compliance Engine
+ *
+ * Implements Google Search & Google Images 2026 standards for AI-generated product media
+ * and digital content labeling according to IPTC PhotoMetadata (DigitalSourceType: TrainedAlgorithmicMedia).
+ */
+export type DigitalSourceType = "trainedAlgorithmicMedia" | "compositeWithTrainedAlgorithmicMedia" | "digitalCapture" | "negativeFilm";
+export interface ImageMetadataInput {
+    imageUrl: string;
+    declaredAlt: string;
+    isAiGenerated: boolean;
+    modelUsed?: string;
+    copyrightNotice?: string;
+    creatorName?: string;
+}
+export interface IptcComplianceReport {
+    imageUrl: string;
+    isCompliantWithGoogleStandards: boolean;
+    detectedSourceType: DigitalSourceType;
+    iptcDigitalSourceTypeCode: string;
+    xmpMetadataSnippet: string;
+    jsonLdImageObject: Record<string, unknown>;
+    recommendations: string[];
+}
+export declare class IptcMediaValidator {
+    /**
+     * Validates and generates IPTC DigitalSourceType metadata tags for Google Images compliance.
+     */
+    static generateIptcPayload(input: ImageMetadataInput): IptcComplianceReport;
+}

package/dist/isr-cache-manager.d.ts

@@ -1,8 +1,9 @@
 /**
  * ⚡ Incremental Static Regeneration (ISR) & Edge Invalidation Cache Manager
  *
- * Implements high-throughput in-memory LRU caching with stale-while-revalidate semantics
- * and selective tag-based invalidation for programmatic pages.
+ * Implements high-throughput in-memory LRU caching (L1) backed by Dragonfly (L2)
+ * with stale-while-revalidate semantics and selective tag-based invalidation
+ * for programmatic pages across the cluster.
  */
 export interface CacheEntry<T> {
     data: T;
@@ -12,6 +13,7 @@ export interface CacheEntry<T> {
 export declare class IsrCacheManager {
     private static cache;
     private static defaultTtlMs;
+    private static dragonfly;
     /**
      * Retrieves an item from cache, or executes the resolver and caches the result.
      */

package/dist/jev-qualifier.d.ts

@@ -0,0 +1,129 @@
+/**
+ * 🎯 TypeSafe Jev SEO Decision Engine
+ *
+ * Implements the fast (System One) decision layer.
+ * Evaluates pages against Google Search Central guidelines, E-E-A-T, and AI
+ * citation readiness (GEO) with typed choices, calibrated confidence bands,
+ * and probability distributions.
+ *
+ * Rule: "A source finds, code decides, Jev judges, the LLM or template writes."
+ */
+export interface JevPageInput {
+    url: string;
+    title: string;
+    opening?: string;
+    text: string;
+    metaDescription?: string;
+    siteContext?: string;
+}
+export type JevPageType = "homepage" | "product_or_service" | "category_or_listing" | "article_or_guide" | "about_or_team" | "contact_or_location" | "pricing" | "case_study_or_proof" | "support_or_docs" | "legal_or_policy" | "other";
+export type JevSearchIntent = "informational" | "commercial" | "transactional" | "navigational" | "local" | "unclear";
+export type JevActionRecommendation = "keep_or_improve" | "rewrite" | "merge_or_remove";
+export interface JevPageQualification {
+    url: string;
+    pageType: JevPageType;
+    intent: JevSearchIntent;
+    action: JevActionRecommendation;
+    importance: number;
+    helpfulness: number;
+    specificity: number;
+    trust: number;
+    citable: number;
+    answerFirst: boolean;
+    answerFirstProb: number;
+    clearNextStep: boolean;
+    clearNextStepProb: number;
+    titleFit?: number;
+    metaFit?: number;
+    decisiveRouting: "automate" | "sample_review" | "require_review";
+    confidenceSummary: {
+        pageTypeConfidence: number;
+        intentConfidence: number;
+        actionConfidence: number;
+        averageConfidence: number;
+    };
+    rawProbabilities?: Record<string, Record<string, number>>;
+    isOfflineHeuristic?: boolean;
+}
+export interface JevCannibalizationResult {
+    urlA: string;
+    urlB: string;
+    isSubstitute: boolean;
+    substituteConfidence: number;
+    recommendation: "keep_both" | "consolidate" | "re_differentiate";
+    explanation: string;
+    probabilities: {
+        distinct: number;
+        partial_overlap: number;
+        same_intent_duplicate: number;
+    };
+}
+export declare const JEV_PAGE_TYPES: Record<JevPageType, string | {
+    what: string;
+    examples?: string;
+    not_for?: string;
+}>;
+export declare const JEV_INTENTS: Record<JevSearchIntent, string>;
+export declare const JEV_ACTIONS: Record<JevActionRecommendation, string>;
+export declare const JEV_IMPORTANCE_LEVELS: string[];
+export declare const JEV_HELPFULNESS_LEVELS: string[];
+export declare const JEV_SPECIFICITY_LEVELS: string[];
+export declare const JEV_CITABLE_LEVELS: string[];
+export declare const JEV_TRUST_LEVELS: string[];
+export declare const JEV_TITLE_FIT_LEVELS: string[];
+export declare const JEV_META_FIT_LEVELS: string[];
+export declare class JevQualifier {
+    static readonly DEFAULT_API_URL = "https://api.typesafe.ai/v1/systemone";
+    static readonly OPENROUTER_API_URL = "https://openrouter.ai/api/v1/systemone";
+    static readonly DEFAULT_MODEL = "jev-latest";
+    static readonly OPENROUTER_MODEL = "typesafe/jev-latest";
+    static readonly DECISIVE_CONFIDENCE_THRESHOLD = 0.8;
+    static readonly NOUL_YES_THRESHOLD = 0.8;
+    static readonly NOUL_NO_THRESHOLD = 0.2;
+    /**
+     * Resolves the appropriate API endpoint, model identifier, and headers
+     * based on whether OpenRouter or TypeSafe AI credentials are provided.
+     */
+    static resolveEndpointAndModel(options?: {
+        apiKey?: string;
+        apiUrl?: string;
+        model?: string;
+    }): {
+        apiKey: string | undefined;
+        apiUrl: string;
+        model: string;
+        headers: Record<string, string>;
+        isOpenRouter: boolean;
+    };
+    /**
+     * Builds the System One JSON request for a single page.
+     */
+    static buildSystemOnePayload(input: JevPageInput, model?: string): Record<string, unknown>;
+    /**
+     * Parses the System One response into a typed PageQualification object with confidence routing.
+     */
+    static parseSystemOneResponse(input: JevPageInput, responseJson: any): JevPageQualification;
+    /**
+     * Qualifies a page via TypeSafe AI Jev System One API or OpenRouter.
+     * If apiKey is not available or the request fails, falls back to offline heuristics.
+     */
+    static qualifyPage(input: JevPageInput, options?: {
+        apiKey?: string;
+        apiUrl?: string;
+        model?: string;
+        fetchFn?: typeof fetch;
+    }): Promise<JevPageQualification>;
+    /**
+     * Pairwise cannibalization check between two pages.
+     */
+    static detectCannibalization(pageA: JevPageInput, pageB: JevPageInput, options?: {
+        apiKey?: string;
+        apiUrl?: string;
+        model?: string;
+        fetchFn?: typeof fetch;
+    }): Promise<JevCannibalizationResult>;
+    /**
+     * Deterministic offline heuristic fallback when no TypeSafe API key is provided.
+     */
+    static offlineHeuristicFallback(input: JevPageInput): JevPageQualification;
+}

package/dist/jobs/retry-queue.d.ts

@@ -0,0 +1,19 @@
+export type JobStatus = 'pending' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+export type JobType = 'crawl' | 'serp' | 'audit' | 'analytics' | 'links' | 'coworker' | 'custom';
+export interface Job {
+    id: string;
+    type: JobType;
+    payload: Record<string, unknown>;
+    status: JobStatus;
+    attempts: number;
+    maxAttempts: number;
+    nextRunAt: string;
+    lastError?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function computeNextRetry(attempts: number, baseMs?: number): string;
+/** Only the fields a retry decision reads, so a job rehydrated from storage can be partial. */
+export type RetryPolicy = Pick<Job, 'status' | 'attempts' | 'maxAttempts'>;
+export declare function shouldRetry(job: RetryPolicy): boolean;
+export declare function enqueueJob(j: Partial<Job>): Job;

package/dist/kafka-producer.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Kafka Producer wrapper for LynxSEO event ingestion
+ * Matches the schema from lynx-seo-go/services/clickhouse-ingest/main.go
+ */
+export interface KafkaEvent {
+    event_id: string;
+    project_id: string;
+    type: string;
+    domain: string;
+    timestamp: number;
+    payload: Record<string, any>;
+}
+export declare const KAFKA_TOPICS: {
+    readonly RAW: "lynxseo.events.raw";
+    readonly ANALYTICS: "lynxseo.events.analytics";
+    readonly CRAWL: "lynxseo.events.crawl";
+    readonly RANK: "lynxseo.events.rank";
+    readonly BACKLINK: "lynxseo.events.backlink";
+};
+export type KafkaTopic = typeof KAFKA_TOPICS[keyof typeof KAFKA_TOPICS];
+export interface KafkaProducerConfig {
+    brokers?: string[];
+    clientId?: string;
+}
+export declare class KafkaProducer {
+    private brokers;
+    private clientId;
+    private connected;
+    constructor(config?: KafkaProducerConfig);
+    /**
+     * Produce a single event to a topic
+     */
+    produce(topic: KafkaTopic | string, event: KafkaEvent): Promise<void>;
+    /**
+     * Produce a batch of events to a topic
+     */
+    produceBatch(topic: KafkaTopic | string, events: KafkaEvent[]): Promise<void>;
+    /**
+     * Flush pending messages
+     */
+    flush(): Promise<void>;
+    disconnect(): Promise<void>;
+}
+/**
+ * Create a Kafka producer instance with default config from environment
+ */
+export declare function createKafkaProducer(config?: KafkaProducerConfig): KafkaProducer;
+export default KafkaProducer;

package/dist/keyword-advanced-catalog.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 📋 KeywordAdvancedEndpointCatalog
+ *
+ * Catalogue des 332 endpoints DataForSEO keyword-oriented.
+ * Mode "Advanced" : l'utilisateur peut choisir n'importe quel endpoint individuellement.
+ * Groupés par famille, filtrés aux keyword endpoints uniquement
+ *.
+ *
+ * Pure In-Memory, 0 dépendance.
+ */
+export type EndpointFamily = "labs.google" | "labs.amazon" | "keyword.google_trends" | "keyword.dataforseo_trends" | "keyword.google_ads" | "keyword.bing" | "serp.google" | "content" | "ai";
+export interface EndpointDefinition {
+    type: string;
+    family: EndpointFamily;
+    name: string;
+    description: string;
+    /** true = endpoint fictif/stub (coût 0) */
+    stub?: boolean;
+    /** Paramètres requis */
+    requiredParams: string[];
+    /** Paramètres optionnels */
+    optionalParams?: string[];
+    /** Coût estimé en cents */
+    estimatedCents?: number;
+    /** Catégorie sémantique */
+    category: "volume" | "difficulty" | "intent" | "trends" | "serp" | "content" | "ai" | "related" | "competitors";
+}
+/** Catalogue complet — 332 endpoints keyword-oriented DataForSEO */
+export declare const ENDPOINT_CATALOG: EndpointDefinition[];
+export declare class KeywordAdvancedEndpointCatalog {
+    /**
+     * Tous les endpoints, groupés par famille.
+     */
+    static getAll(): EndpointDefinition[];
+    /**
+     * Endpoints filtrés par famille.
+     */
+    static byFamily(family: EndpointFamily): EndpointDefinition[];
+    /**
+     * Endpoints filtrés par catégorie sémantique.
+     */
+    static byCategory(category: EndpointDefinition["category"]): EndpointDefinition[];
+    /**
+     * Recherche par nom ou type.
+     */
+    static search(query: string): EndpointDefinition[];
+    /**
+     * Cherche un endpoint par son type exact.
+     */
+    static findByType(type: string): EndpointDefinition | undefined;
+    /**
+     * Familles disponibles dans le catalogue.
+     */
+    static getFamilies(): EndpointFamily[];
+    /**
+     * Nombre total d'endpoints dans le catalogue.
+     */
+    static count(): number;
+}

package/dist/keyword-analytics-engine.d.ts

@@ -0,0 +1,119 @@
+/**
+ * 📊 KeywordAnalyticsEngine
+ *
+ * Calcule toutes les analytics dashboard depuis les résultats fusionnés :
+ * - Opportunity map (difficulty vs volume, scatter)
+ * - Difficulty bands (Easy/Medium/Hard/Very Hard)
+ * - Aggregate trend mensuel/trimestriel/annuel
+ * - Top keywords par volume
+ * - Easiest wins (faible KD + fort volume)
+ * - Intent distribution
+ * - CPC landscape
+ *
+ * Pure In-Memory, 0 dépendance, < 1ms pour 1000 keywords.
+ */
+import type { KeywordRow } from "./keyword-export-engine";
+export type { KeywordRow };
+export interface ScatterPoint {
+    keyword: string;
+    difficulty: number;
+    volume: number;
+    cpc: number;
+    intent: string;
+}
+export interface DifficultySlice {
+    name: string;
+    value: number;
+    color: string;
+    minKd: number;
+    maxKd: number;
+}
+export interface MonthPoint {
+    key: string;
+    label: string;
+    volume: number;
+    coverage: number;
+}
+export interface AggregateTrend {
+    monthly: number | null;
+    quarterly: number | null;
+    yearly: number | null;
+}
+export interface TopKeyword {
+    keyword: string;
+    volume: number;
+    difficulty: number;
+    cpc: number;
+    intent: string;
+}
+export interface OpportunityKeyword extends TopKeyword {
+    /** Score 0–100 : fort volume + faible KD = valeur élevée */
+    opportunityScore: number;
+    label: "🏆 Meilleure opportunité" | "✅ Bonne opportunité" | "⚠ Compétitif" | "❌ Difficile";
+}
+export interface IntentSlice {
+    intent: string;
+    count: number;
+    volumeShare: number;
+    color: string;
+}
+export interface KeywordAnalytics {
+    totalKeywords: number;
+    totalVolume: number;
+    avgDifficulty: number;
+    avgCpc: number;
+    scatterPoints: ScatterPoint[];
+    difficultyBands: DifficultySlice[];
+    monthlyAggregate: MonthPoint[];
+    aggregateTrend: AggregateTrend;
+    topByVolume: TopKeyword[];
+    easiestWins: OpportunityKeyword[];
+    intentDistribution: IntentSlice[];
+    hasEnoughData: boolean;
+}
+export declare class KeywordAnalyticsEngine {
+    /**
+     * Point d'entrée principal — calcule toutes les analytics depuis les rows fusionnées.
+     */
+    static compute(rows: KeywordRow[]): KeywordAnalytics;
+    /**
+     * Points pour la scatter (opportunity map difficulty vs volume).
+     */
+    private static computeScatter;
+    /**
+     * Répartition des keywords par bandes de difficulté KD (Easy/Medium/Hard/Very Hard).
+     */
+    private static computeDifficultyBands;
+    /**
+     * Agrégation mensuelle du volume total (tous keywords confondus).
+     */
+    private static aggregateMonthly;
+    /**
+     * Calcule la tendance % mensuelle, trimestrielle et annuelle.
+     * Ne moyenne PAS les %, compare les volumes agrégés (évite le biais des petits keywords).
+     */
+    private static computeAggregateTrend;
+    private static windowChange;
+    private static shiftMonth;
+    /**
+     * Top keywords par volume décroissant.
+     */
+    private static topByVolume;
+    /**
+     * "Easiest wins" : keywords avec fort volume ET faible difficulté.
+     * Score = (volume_normalisé × 0.6) + ((100 - kd) × 0.4)
+     */
+    static easiestWins(rows: KeywordRow[], n?: number): OpportunityKeyword[];
+    /**
+     * Répartition des intentions de recherche par count et part de volume.
+     */
+    private static computeIntentDistribution;
+    /**
+     * Formate un nombre de volume (ex: 18100 → "18 100" / 1500000 → "1,5M")
+     */
+    static formatVolume(volume: number): string;
+    /**
+     * Formate une tendance % avec signe
+     */
+    static formatTrend(trend: number | null): string;
+}

package/dist/keyword-bundle-orchestrator.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 🎯 KeywordBundleOrchestrator
+ *
+ * Sélection intelligente d'endpoints par groupe (spine / demand / serp / cross-engine).
+ * Ordre: cheapest-first, déduplication, skip des sources non supportées par le marché.
+ * 0 dépendance externe — logic In-Memory pure O(1).
+ */
+export type BundleGroup = "spine" | "demand" | "cross-engine" | "serp";
+export interface BundleEntry {
+    type: string;
+    group: BundleGroup;
+    label: string;
+    /** Ce que cet endpoint contribue que les autres n'apportent pas */
+    contributes: string;
+    /** Si true, l'échec de cet endpoint annule le run entier */
+    required?: boolean;
+    /** Source externe nécessaire (ex: "amazon", "bing") */
+    requiresSource?: "bing" | "amazon";
+    /** Coût estimé mesuré en cents (calibré sur des vrais runs) */
+    measuredCents?: number;
+}
+/** Bundle standard de 19 appels*/
+export declare const KEYWORD_BUNDLE: BundleEntry[];
+export declare const BUNDLE_GROUP_LABELS: Record<BundleGroup, string>;
+export declare class KeywordBundleOrchestrator {
+    /**
+     * Retourne les entries du bundle filtré pour un couple (country, language).
+     * Skip les sources non supportées par le marché avant tout appel API.
+     */
+    static entriesForMarket(country?: string | null, language?: string | null, options?: {
+        skipCrossEngine?: boolean;
+        skipDemand?: boolean;
+    }): BundleEntry[];
+    /** Types d'endpoints uniquement */
+    static typesForMarket(country?: string | null, language?: string | null): string[];
+    /** Entrée par type */
+    static findEntry(type: string): BundleEntry | undefined;
+    /** Plan d'exécution groupé par phases pour affichage de progression */
+    static executionPlan(country?: string | null): {
+        phase: BundleGroup;
+        label: string;
+        entries: BundleEntry[];
+    }[];
+}

package/dist/keyword-cost-estimator.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 💰 KeywordCostEstimator
+ *
+ * Estime le coût en cents d'un bundle d'appels API avant exécution.
+ * Prix calibrés sur des vrais runs DataForSEO (mesurés, pas estimés).
+ * Pure In-Memory, 0 I/O, < 0.01ms par calcul.
+ */
+export interface CostEstimate {
+    estimatedCents: number;
+    notes: string;
+    isMeasured: boolean;
+}
+export interface BundleCostSummary {
+    totalCents: number;
+    totalDollars: string;
+    formattedLabel: string;
+    byEndpoint: Array<{
+        type: string;
+        label: string;
+        cents: number;
+        isMeasured: boolean;
+    }>;
+    isFree: boolean;
+}
+export declare class KeywordCostEstimator {
+    /**
+     * Estime le coût d'un seul endpoint.
+     */
+    static estimateEndpoint(type: string): CostEstimate;
+    /**
+     * Estime le coût total d'un batch d'endpoints.
+     * Affiche un label humanisé pour le bouton "Run" avant exécution.
+     */
+    static estimateBatch(types: string[], labels?: Record<string, string>): BundleCostSummary;
+    /**
+     * Formate les cents en label pour bouton.
+     * < 1 cent → "<$0.01"
+     * >= 1 cent → "~$0.XX"
+     */
+    static formatCents(cents: number): string;
+    /**
+     * Récapitulatif lisible pour un rapport de coût post-run.
+     */
+    static formatBatchReport(summary: BundleCostSummary): string;
+}

package/dist/keyword-export-engine.d.ts

@@ -0,0 +1,52 @@
+/**
+ * 📤 KeywordExportEngine
+ *
+ * Export des résultats de keyword research en CSV (anti-formula Excel),
+ * JSON structuré, et rapport texte.
+ * Pure, sans dépendance DOM (downloadFile est un helper client séparé).
+ */
+export interface KeywordRow {
+    keyword: string;
+    volume?: number;
+    cpc?: number;
+    difficulty?: number;
+    intent?: string;
+    trend?: number;
+    competition?: number;
+    monthlyVolume?: number[];
+    serpFeatures?: string[];
+    [key: string]: unknown;
+}
+export interface ExportOptions {
+    /** Colonnes à inclure dans le CSV (undefined = toutes les colonnes non-objet) */
+    columns?: string[];
+    /** Colonnes à exclure explicitement */
+    excludeColumns?: string[];
+    /** Séparateur de colonnes (défaut: virgule) */
+    separator?: "," | ";" | "\t";
+}
+export declare class KeywordExportEngine {
+    /**
+     * Génère un CSV valide avec protection anti-injection de formule Excel.
+     * Un keyword comme "-seo" est préfixé d'un tab (\t) pour éviter
+     * qu'Excel l'interprète comme formule.
+     */
+    static toCsv(rows: KeywordRow[], options?: ExportOptions): string;
+    /**
+     * Formatte une valeur pour une cellule CSV.
+     * Anti-injection formule Excel : préfixe \t si la valeur commence par = + - @
+     */
+    private static csvCell;
+    /**
+     * Sérialise en JSON structuré avec indentation.
+     */
+    static toJson(rows: KeywordRow[], indent?: number): string;
+    /**
+     * Génère un rapport texte formaté (pour copier/coller ou afficher en terminal).
+     */
+    static toTextReport(rows: KeywordRow[], title?: string): string;
+    /**
+     * Nom de fichier sûr pour export (sans caractères spéciaux).
+     */
+    static safeFilename(keyword: string, extension: "csv" | "json" | "txt"): string;
+}

package/dist/keyword-market-validator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 🌍 KeywordMarketValidator
+ *
+ * Valide les couples pays/langue avant tout appel DataForSEO.
+ * Prévient les dépenses inutiles sur des paires invalides.
+ * 94 marchés × 46 langues supportés.
+ * Pure In-Memory, < 0.01ms par validation.
+ */
+export interface MarketValidationResult {
+    isValid: boolean;
+    country: string;
+    language: string;
+    countryName: string;
+    languageName: string;
+    supportsBing: boolean;
+    supportsAmazon: boolean;
+    warnings: string[];
+}
+export interface MarketInfo {
+    code: string;
+    name: string;
+    primaryLanguages: string[];
+    supportsBing: boolean;
+    supportsAmazon: boolean;
+}
+export declare class KeywordMarketValidator {
+    /** Valide un couple country + language avant tout appel DataForSEO */
+    static validate(country: string, language: string): MarketValidationResult;
+    /** Liste tous les marchés disponibles */
+    static getAllMarkets(): MarketInfo[];
+    /** Suggère la langue principale pour un pays */
+    static suggestLanguage(country: string): string | undefined;
+    /** Filtre pour affichage de sélecteur UI */
+    static searchMarkets(query: string): MarketInfo[];
+}